An intent gets worked, not filed.

How an intent progresses

What an intent picks up as it is worked.

Five things, and none of them is a stage it passes through — they are all live at once. The agent revisits what is understood and whether it is ready on every turn, which is why an intent gets stronger by being worked rather than by advancing.

What the record holds

A conversation on one side. A record being built on the other.

It exists from the first message and grows as you talk. The eight below are where most intents start, not a form to complete — people and agents add to them, revise them, and put claims under them as the work is understood. Every part carries the evidence behind it and a state saying how solid it is, so “we never decided that” stops being a conversation anyone has to have.

Three claims, three states

Every line in an intent is a claim, and every claim carries where it came from and how solid it is. A disagreement is a state the record holds, in plain sight, until somebody settles it.

The knowledge graph

Records do not sit apart. Five intents across one workspace and the core they share — each node is something the organisation established once, and each edge says how the two relate. Nothing here was entered twice.

How the intent gets deeper

It asks before it assumes.

Most tools in this category are competing to ask you less. This one is built the other way round — because the questions nobody asked are exactly what the agent ends up guessing.

Every proposal is the agent’s. Every acceptance is yours.

That is where the grounding actually comes from — not from the model being careful, but from a person having said yes. It is also what makes it safe to let the model propose freely: nothing it says can settle anything on its own.

Grounding is mandatory. An agent that cannot ground its move must ask instead — so its uncertainty becomes a question in your queue rather than a guess twenty steps deep.

Authorship is always “Priya’s agent, for Priya”. A commenter’s agent cannot write a claim, because she cannot. This is a check on the write path, not a label.

The record is append-only and replayable. Deletion is a state, not an erasure — so any past decision, and the reasoning under it, can be reconstructed.

The envelope holds wherever you set the autonomy dial. It is what makes the dial safe to move at all.

What an agent is given

You don’t write the harness. You build the intent.

A harness is four things: the tools an agent may use, the boundary it may not cross, what it needs to know, and how anyone can tell it worked. An intent already contains all four.

How an intent's history is kept

Revisions run down the spine and each build hangs off the revision it came from. Two builds from one revision are siblings: both valid, neither replacing the other.

The shared understanding

A conversation on one side. A record being built on the other, growing as you talk.

The record exists from the first message. Eight typed sections, from at a glance through to what happens if it breaks. Each carries the evidence behind it and a state saying how solid it is. Readiness is computed from those states and shown as vague, actionable or ready.

• Every value carries the evidence it came from
• Claims can be proposed, contested and resolved in the open
• Inference is marked inferred — confirm, never quietly folded in

Collaboration and assurance

Many people and their agents on one intent, live — and a way to say who is answerable.

Three independent layers that combine rather than compete. What you may do (viewer, commenter, contributor). What you are answerable for (reviewer, attestor, approver, evaluator). And where you belong (org admin, workspace admin, member, guest). One person can be a contributor and a reviewer; an outside auditor can attest without ever seeing the workspace.

• Every contributor is equal — there is deliberately no owner role
• Attestation is bound to a named standard, and blocks publish
• Presence, competing proposals and changes arriving without a refresh

Artifacts and the registry

What the understanding produces, versioned and addressable.

A build produces an OKF bundle — vendor-neutral markdown plus a relationship graph, not a proprietary container. Checkpoints give free undo while a draft is moving; versions are immutable published snapshots you can point at. The registry is the catalog across every intent your organisation has worked.

• Checkpoints are one-click undo; versions are permanent
• Every version is addressable and shareable
• The format is open, so the knowledge is not trapped in a schema only we can read

The knowledge graph

The same understanding, kept — and everyone can build one of these. Few can afford to run one.

This is the first cluster at a different scale, not a second product. The shared understanding one intent reaches — its claims, its evidence, its decisions, the systems it touched — is exactly what accumulates here. Bring your own sources and every intent contributes back, until what you have is a grounded map of how your organisation actually works and each new intent starts richer than the last.

• The position is cost: construction, search, refresh and maintenance
• Vocabularies capture your organisation’s own controlled language
• Evaluations define what “good” means for your work, not ours

Control and economics

What makes the rest of it safe to grant.

Token consumption is visible before a run, measured after, and capped by policy at workspace level — so unsupervised work has a floor rather than an open exposure. Every action is attributable and the record is append-only. And the whole thing runs as a managed service or inside your own network, from the same artifact.

• Spend caps at workspace level, set by an admin
• An append-only audit trail; deletion is a state, not an erasure
• SaaS or your own infrastructure, twelve-factor, no SaaS-only dependencies