---
title: Intent
description: "Goals and success criteria, the is/ought firewall, and how moves rank against what the agent is after."
---
## What Intent Is
Beliefs say what is true. Intent says what the agent is trying to make true. The two never share a track, because the moment a want can edit a fact, the agent starts believing whatever it most wants to be the case.
Intent holds the agent's goals and unknowns: the job it is steering toward, the boundaries it has to respect, and the questions it has not answered yet. "Map the competitive landscape" is intent. It sets a direction and cannot be true or false. "The market is $4.2B" is a belief. Evidence can support it or refute it. A memory system files both as text and treats them alike. thinkⁿ keeps them apart on purpose, because they answer different questions and obey different rules: evidence moves beliefs, and nothing else does.
## Goals carry success criteria
A goal declares what done looks like. Alongside the text, a goal carries its **success criteria**: the predicates that say when it is met. That is what lets the agent tell "still working" from "finished" without a human in the loop.
```ts
await beliefs.add('Ship the v2 pricing page', { type: 'goal' })
await beliefs.add('Identify top 3 market opportunities', { type: 'goal' })
```
Goals drive action selection. They tell the system what to answer and which gaps are worth closing. What they do not do is carry a posterior. A goal holds no probability and never touches the evidence math. Pursuing a hypothesis is not evidence for it, so an agent should not grow surer of a claim just because it set out to prove that claim.
## Constraints
A constraint declares what must or should hold while the agent works. Some are hard boundaries it may not cross; others are soft preferences it should honor when it can. A constraint is a goal-typed belief: it states something the agent ought to keep true, not something evidence can refute, so it rides the intent track alongside the goals it bounds.
```ts
await beliefs.add('Must stay SOC2-compliant', { type: 'goal' })
await beliefs.add('Prefer open-source dependencies', { type: 'goal' })
```
Whether a constraint is hard or soft lives in your world's [policy](/dev/core/policy), not in a flag on the call. The same `goal` type carries both; policy is what tells them apart. When a worldview is projected, an action that runs into an active hard constraint comes back `flagged` with the constraint named, and an action a constraint calls out by name comes back `blocked`. Either way the agent sees the conflict before it acts, not after. That gating is a modeling lens you encode in the world definition today. There is no separate `severity` argument on `add`, and there will not be one: the hard-or-soft distinction is policy's job, not the call site's.
## The is/ought firewall
Everything on this page rests on one rule: evidence updates beliefs, and preferences and goals never do. Facts enter through one door and move the posterior. Wants and oughts enter through another, get recorded as intent, and stay out of the evidence math entirely.
| Input | Type | Effect |
|-------|------|--------|
| "The TAM is $5B" | Factual | Updates the market-size belief |
| "Gartner reports 34% growth" | Factual | Updates the growth-rate belief |
| "I want to target enterprise" | Normative | Recorded as a goal |
| "We must support SOC2" | Normative | Recorded as a constraint |
Two stated facts move the posteriors. Two normative inputs steer the work without touching a single probability. That is the firewall. Drop it and the failure mode arrives fast: every "I want X" nudges the posterior toward X being true, and the loudest stakeholder wins regardless of the evidence. Keep it and a strong preference decides what the agent pursues while the balance of evidence stays honest about what is actually so.
A user repeating "I want X" would, in a naive system, inflate the agent's confidence that X is *true*: preference masquerading as evidence. The firewall holds factual claims and normative intent apart, so conviction steers the work but never distorts what the agent believes.
## Gaps: named unknowns, made first class
A gap is something the agent has not investigated or cannot answer yet. Most systems treat ignorance as silence. thinkⁿ makes it an object you can read, rank, and act on.
```ts
await beliefs.add('No data on enterprise pricing models', { type: 'gap' })
await beliefs.add('Missing APAC market analysis', { type: 'gap' })
```
Gaps are what turn a world model into a research plan. An agent that knows what it does not know can decide where to look next instead of guessing. Each open gap pulls [clarity](/dev/core/clarity) down, and high-dependency gaps (the ones many beliefs hang on) pull harder, so the most consequential unknowns rise to the top on their own.
When the agent has answered one, `resolve()` marks it closed; it accepts the gap's text or its id. A resolved gap stops pulling clarity down and updates the world model.
```ts
await beliefs.resolve('Missing APAC market analysis')
```
## Intent is what ranks moves
Goals and gaps do real work. They are the criterion the next-move surface is scored against. Out of all the open questions, the **limiting factor** is the single one most in the way of the goal, and the [moves](/dev/core/moves) the agent sees are ranked by how much each would carry it toward what it is after. The destination decides what is worth doing next.
Goals and gaps ride back on every orientation read, so the agent opens each turn already knowing what it is chasing and what it is missing:
```ts
const world = await beliefs.read()
console.log(world.goals) // ['Ship the v2 pricing page', ...]
console.log(world.gaps) // ['No data on enterprise pricing models']
const ctx = await beliefs.before('draft the pricing tiers')
console.log(ctx.moves[0]) // the top-ranked next move, given the goal
```
## You declare intent; the engine reads it
Goals, success criteria, and constraints are part of the world you declare for the domain. The engine reads them to scope the worldview and rank moves. It does not invent goals or decide what counts as done. You set the destination and the boundaries. The engine keeps them honest against the evidence and turns them into a ranked plan.