Praecise Harness v1.1.0 Get started

Documentation · Trust

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):

ts
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.

ts
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.

Edit this page on GitHub · Read it as Markdown

    Type to search. Arrow keys move, Enter opens.