Product
An intent gets worked, not filed.
A conversation on one side, a structured record on the other — questioned, evidenced and agreed until it is strong enough for someone, or something, to act on.
How the work moves
Five things an intent accumulates — not five steps it passes through.
They are 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.
Capture
What is being asked for?
Understand
What do we still not know?
Gate
Is this strong enough yet?
Approve
Who is answerable for it?
Publish
What exactly did we agree?
What gets built
A conversation on one side. A structured record on the other.
The record exists from the first message and fills in as you talk. Every part of it 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.
Goal
What are we actually trying to achieve?
Covers
What is inside this piece of work?
Not included
What is explicitly out — so nobody assumes it in?
Background
What context does anyone acting on this need?
Touches
Which systems and teams does it reach?
Done means
How will we know it worked?
If it breaks
What happens when it goes wrong?
Readiness is computed from those states — shown as vague, actionable or ready, never a score. A number would invite an argument about the number instead of about the work.
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.
It asks in batches
Questions arrive together with the options already laid out, so answering is a few decisions rather than an interview.
What it infers, it marks
Anything the agent worked out rather than was told is flagged inferred — confirm. It is never quietly folded in as though you had said it.
It shows what is thin
Every part of the intent carries a state — weak, ambiguous, conflicting — so the gaps are visible before the build, not discovered after it.
It cannot assert what it cannot cite
An agent that has no grounding for a claim has to ask instead. Its uncertainty becomes a question in your queue rather than a guess twenty steps deep.
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.
How it holds
Every product in this category promises fewer hallucinations. Here is the mechanism.
01
An agent may not assert what it cannot cite.
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.
02
An agent acts for someone, and never exceeds them.
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.
03
Nothing is erased.
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.
04
Nothing happens that is not attributable, grounded, bounded, and revocable.
The envelope holds wherever you set the autonomy dial. It is what makes the dial safe to move at all.
Anything a person must defend in an audit is code. Anything that only has to be helpful is the model.
What you hand over
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.
Tools
What may be acted on
touches
The systems this intent reaches — named, and agreed by the people who own them.
Permissions
What may not
covers · not included · if it breaks
The boundary, stated positively and negatively, plus what happens when it goes wrong.
Memory
What it must know
background + evidence
The context, the attached evidence, and the prior intents this one builds on.
Verification
How we know it worked
done means
The success criterion, agreed in advance rather than argued afterwards.
So the thing an agent runs on is compiled from evidence your team already agreed on — not written from memory, per model, and rewritten every release.
Which is also why it can be governed at all: prose has nothing to attribute, nothing to attest against, and no basis on which to widen what an agent may do.