Models, tools, capability, identity and authority
Five words carry most of this book. In everyday conversation they blur together. In these systems each one is enforced by a different component.
Model
A model call returns a sample: fluent, often right, sometimes wrong, never guaranteed. It has no access to your systems and no memory between calls. Running at temperature 0 narrows the variation but does not remove it. Every architecture in this book treats the model as an untrusted, probabilistic decision maker. It is good at interpreting ambiguous intent, choosing among tools, synthesising evidence and explaining. It is not a source of truth and not a holder of authority.
Tool
A tool is a typed function the model may request. The runtime, not the model, executes it. With native tool calling the request arrives as structured data rather than prose. A tool's description is effectively part of the prompt, and its granularity decides how many round trips, and how many failure points, a task needs.
Capability
A capability is what a component can cause at all. In these systems it is usually defined by a tool surface behind a protocol boundary:
- the template's MCP server and the agent's
include:list; - exactly four wallet tools in Arktos, none of which returns secret material;
- exactly eight reviewed Ash actions exposed over MCP in Tauros.
A capability says nothing about whether a particular use is allowed. That needs identity and authority.
Identity
Identity answers who is calling, and the rule across the book is that neither the model nor the browser decides it. In Part I a gateway authenticates the user and mints identity headers that downstream services accept only from it. In Part IV the wallet owner is the API key presented in a header, resolved by an HMAC lookup, and never a tool argument. In Part V humans and agents are different kinds of actor, and an agent's API key identifies an agent, never an approver.
Permission and authority
These two are easy to conflate, and the distinction matters most:
- Permission is what an actor may do under policy: an Ash policy, an authorisation check, a row-ownership rule.
- Authority is the standing to make a consequential decision bind: to approve this invoice, to record this investment decision, to sign with this key. In these systems authority is held by a human, or by deterministic code acting on a human's explicit, verifiable decision, or by a key held outside the model.
An agent can have the capability to call a tool and the permission to propose, and still have no authority over the outcome. Tauros states this directly: an AI's capability is not authority. The Capability, permission and authority chapter compares how each project enforces the difference.
The boundary that matters
Where authority matters, it is enforced outside the model.
"Outside the model" means in a place a prompt cannot reach:
- a type or a schema: a value the model can never construct;
- a policy: a check that runs for every interface, not just the chat;
- a transaction: re-derive the state under a lock, then apply and audit together;
- a cryptographic check: a signed approval token, an HMAC-looked-up key. Its strength depends on who holds the key: the model never does, but a trusted runtime component does, and that component must be protected in its own right;
- a human decision: one that names the exact thing being approved.
The rest of the book is about building those places and testing that they hold.
Eight trust boundaries: a working vocabulary
The five words above describe components. When the book compares projects, or compares a project with external infrastructure, it also needs names for the questions every consequential system has to answer somewhere. CognoKratos uses eight:
| Boundary | Core question | Studied most directly in |
|---|---|---|
| Identity | Who is acting? | Part I (gateway identity), Part IV (API-key owner), Part V (humans and agents as distinct actors) |
| Capability | What can they reach or invoke at all? | Part I (MCP tool list), Part IV (four public-only tools), Part V (eight reviewed tools) |
| Policy | Is this particular action permitted? | Part III (versioned rules engine), Part V (Ash policies and state machine) |
| Durability | What survives failure, retry and restart? | Part II (runs, checkpoints, resume), Part V (idempotency keys) |
| Authority | Who can make the action binding? | Part I (opt-in signed approval), Part III (mandatory approval), Part V (exact-payload approval) |
| Evidence | Can we reconstruct, and ideally prove, what happened? | Part I (one trace per request), Parts III and V (append-only decision and event history) |
| Custody | Who ultimately controls the secrets, or the value? | Part IV (model, service and operator custody) |
| Settlement | How does an authorised economic action become final? | none yet: a research direction (Part VI design exercise) |
Policy is where the book's permission is decided, and authority keeps the meaning given above. Capability and custody are easy to confuse: a service can offer a cryptographic capability while the operator, not the caller, holds custody of the key behind it.
This is a working vocabulary, not a standard. It has no conformance levels and no requirement numbers, and the boundaries overlap: an approval token is evidence and a carrier of authority. Its value is that the same eight questions can be asked of any implementation, whichever framework, cloud or protocol provides it. Where CognoKratos fits maps each boundary to external projects that address it.