What you are trusting
A framework does not get to assume where it will run, so here is what this one assumes and what it does not.
The dev server authenticates. It mints a token on startup and prints it; every
/api/* and /mcp request needs it. It binds loopback by default, and it refuses to
start on an address the network can see unless you have configured authentication —
a refusal rather than a warning, because that misconfiguration is the one that turns
every other risk into a remote one. Mutating requests are checked against an origin
allowlist and a Host allowlist, and must be application/json, so a page you happen
to be visiting cannot drive it and a rebound DNS name cannot read it.
Approvals are attributed; they are non-repudiable only if you make them so. With no
signer wired, an approval records who claimed it and is marked unsigned — the
framework will not synthesise a signature, because a fake one is a lie the audit trail
carries forever. Wire approvals.sign and approvals.verify and the picture changes:
a signature that does not verify is refused rather than stored, and a quorum counts the
subjects your verifier proved, never the names a caller typed. A gate that requires
two people refuses to start without a verifier, rather than accepting one person twice.
Agents are not sandboxed from the control plane. guard.ts is the boundary for what
a tool may do, and it sees which channel a call arrived on. A plan step gives a model
no tools unless you name them.
Everything is persisted in plaintext unless you seal it. Prompts, inputs, outputs and
conversations go to <root>/.praecise/, owner-only (0700/0600), with no retention
policy. Three things can be sealed at rest, each with a cipher of your own:
workflow runs (runCipher), conversations (threads) and what agents remember
into files (memory):
const app = await App.load({ root, runCipher: cipher, threads: cipher, memory: cipher });threads also takes a backend in place of a cipher (Conversations), to keep
conversations somewhere else altogether. Memory is kept somewhere else by naming a
store, on the agent or as the app's store. Still plain: the routing record, recordings, the ingest cache and source cursors. Credentials quoted by an exception are redacted before anything is
written. If you process personal data, this directory is your record and app.redact()
is your erasure mechanism.
Limits are enforced, not declared. A budget counts planning and judging, not just the obvious calls; concurrency is bounded across the whole run rather than per step, so nesting cannot multiply it; and every model call has a timeout.
The app has the last word on spending. A meter is asked before every model
call the runtime makes: each rung tried, each sample, a climb, a summary, advice,
a transcription, and the calls of an agent asked on the way.
const app = await App.load({
root,
meter: {
reserve: (call) => (spent(call.caller) > allowance ? "This account has used its allowance." : undefined),
settle: (call, usage) => record(call.caller, usage),
},
});reserve is handed the agent, the rung, the caller, the context and an
estimate. A sentence back refuses the call and ends the request with
MeterRefused; a refusal is never answered by climbing to another model.
settle is told what the call took. Live sessions and embeddings are not
metered, and a permission classifier is only when it is passed the same meter.