Intent Studio
Agents don’t fail because the model is weak. They fail because the intent was thin.
Intent Studio is where teams and their agents build an intent rich enough to actually get done — grounded in evidence, contested in the open, and governed before anything expensive runs.
The wedge
An agent handed a thin intent does the worst possible thing: it proceeds.
It fills every gap with an assumption — silently, confidently. Assumptions compound, because each one becomes the ground the next step stands on. By the time anything is produced, the plan rests on a stack of guesses nobody agreed to.
The gap is invisible while it is cheap to fix, and obvious once it is not.
That gap bills four ways at once
Hallucination
The agent asserts what it was never told and could not know.
Iteration
Round after round of “not quite, try again” — each one a full paid run.
Rework
The most expensive people in the building fixing an agent’s guesses.
Corrupted plans
Work that was wrong at step two and only visibly wrong at step twenty.
The shift
A workspace of five people is not five conversations with five assistants.
It is five people and five delegated agents contributing to one understanding — each seeing what the others have done to it.
Every agent acts for a named person, and can never exceed what that person could do.
The agent is in the room
Each member’s agent can reason over what the others — and their agents — proposed, contested, accepted or resolved, and bring that into the conversation where the work is actually happening. That is the coordination product, and it is the thing a per-user assistant structurally cannot have.
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.
Capabilities
What you actually get
Five clusters, each doing one job in the same product.
The shared understanding
A conversation that builds a structured record from message one.
- Typed fields — Goal · Covers · Not included · Background · Touches · Done means · If it breaks
- Every value carries the evidence behind it
- Claims are proposed, contested and resolved in the open
- Readiness shows as Vague · Actionable · Ready — never a number
Collaboration and assurance
Many people and their agents on one intent, live.
- Viewer · Commenter · Contributor — and every Contributor is equal
- Reviewer advises · Attestor blocks against a named standard · Approver releases
- Presence, competing proposals, changes arriving without a refresh
- Guests scoped to named intents, never the workspace
Artifacts and the registry
What the understanding produces, versioned and immutable.
- Builds produce an OKF bundle — vendor-neutral markdown plus a relationship graph
- Checkpoints give free undo on drafts
- Versions are immutable published snapshots, addressable and shareable
- The Registry is the catalog across every intent
Knowledge and context
Everyone can build a knowledge graph. Few can run one affordably.
- Bring your own sources; every intent contributes its context back
- The position is cost — construction, search, refresh, maintenance
- Vocabularies capture the organisation’s own controlled language
- Evaluations define what “good” means for your work
Control and economics
What makes the rest of it safe to grant.
- Token consumption visible before a run, measured after, capped by policy
- A complete, append-only audit trail
- Hand-off instead of download — scoped, logged, revocable
- SaaS or your own infrastructure, from the same artifact
Autonomy you can grant
Capability is purchasable. Defending letting it act is not.
Every other product picks a point on this line and hard-codes it. Copilots stay propose-only, so the human is the throughput ceiling forever. Autonomous agents act by default, which is unsellable into a regulated process. You set it, and move it as your own evidence supports.
Propose
where you startSuggest claims, questions and evidence. A person agrees to everything.
Needs: Nothing. This is the safe floor.
Settle the immaterial
Close low-consequence items alone; escalate anything material.
Needs: That materiality is defined by policy, not by the model’s judgement.
Settle within a domain
Act unsupervised inside an intent type where its record supports it.
Needs: A track record that is measured, and specific to that domain.
Build and prepare
Produce artifacts and ready them for release without a human in each step.
Needs: That the gates still hold — attestation and approval unchanged.
Act, with gates
Carry work through, stopping only where policy demands a named human.
Needs: Halt and revoke are instant, and every step is reconstructable.
What holds wherever you set it
Nothing happens that is not attributable, grounded, bounded, and revocable.
That envelope is what makes the line safe to move at all — and why widening it is a decision you can defend afterwards rather than a leap of faith.
Built for the enterprise
The questions procurement asks, answered structurally.
Runs on your infrastructure
SaaS and on-premises from the same artifact — 12-factor config, no SaaS-only dependencies. The only runtime external dependency is the model provider you configure.
Nothing leaves as a file
There is no download button. Hand-off is a scoped credential bound to a published version, with a read log, revocable at any time — because a downloaded file could not be recalled.
Every action is attributable
Who did what, when, and why — append-only and replayable. Deletion is a state, not an erasure, so any past decision can be reconstructed.
Spend is bounded, not open-ended
Token consumption is visible before a run, measured after, and capped by policy at workspace level — so unsupervised work has a floor.
What accumulates
Every intent leaves behind more than its artifact.
The claims and the evidence under them, the decisions and the reasons given, the systems touched, the prior intents it built on. Each one is a node and an edge.
Those accumulate into a knowledge graph of how your organisation actually works — not an org chart or a wiki, but a grounded record of real decisions, real constraints and real outcomes. Every intent after it starts richer than the last.
It is also what makes widening autonomy defensible: you can only grant more where you can measure what happened, and this is the measurement.
See it on your own work
The fastest way to understand Intent Studio is to walk one of your own intents through it.