Intent

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.

1await beliefs.add('Ship the v2 pricing page', { type: 'goal' })
2await 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.

1await beliefs.add('Must stay SOC2-compliant', { type: 'goal' })
2await beliefs.add('Prefer open-source dependencies', { type: 'goal' })

Whether a constraint is hard or soft lives in your world's 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.

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.

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.

1await beliefs.add('No data on enterprise pricing models', { type: 'gap' })
2await 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 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.

1await 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 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:

1const world = await beliefs.read()
2
3console.log(world.goals) // ['Ship the v2 pricing page', ...]
4console.log(world.gaps)  // ['No data on enterprise pricing models']
5
6const ctx = await beliefs.before('draft the pricing tiers')
7console.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.