# configuration/strings/coordination.strings.ts

> 96 lines of code and 6 definitions.

Tree: Site tree
Language: typescript
Layer: product
Canonical: https://banes-lab.com/anatomy/tree#file-configuration-strings-coordination-strings-ts
Source text: https://banes-lab.com/assets/sources/source.c4e013146e0d1c937a59f6838723475b5e8e8b9648d9c4e8d02b265ff9284293.generated.txt

## Definitions

- `HUMAN_DIAGRAM` (lexical_declaration, line 6)
- `AGENT_DIAGRAM` (lexical_declaration, line 9)
- `CREATION_DIAGRAM` (lexical_declaration, line 12)
- `HUMAN_SECTION` (lexical_declaration, line 15)
- `AGENT_SECTION` (lexical_declaration, line 56)
- `COORDINATION_SECTIONS` (lexical_declaration, line 102, exported)

## Source

```typescript
import { AGENT_SECTION_ICON, HUMAN_SECTION_ICON } from "#configuration/icons/coordination.icons";
import { AGENT_SECTION_ID, HUMAN_SECTION_ID } from "#core/ids/coordination.ids";
import type { Section } from "#types/document.types";
import { stageLink as stage } from "#domain/converters/link.converter";

const HUMAN_DIAGRAM =
    'flowchart TB\n    operator["The developer"]\n    ai["The model"]\n    tree["The tree"]\n    operator -- what the work is for, what finished means --> ai\n    operator -- a correction, brief, once --> ai\n    ai -- the shape of the work --> tree\n    ai -- a question through one channel, recommendation first --> operator\n    ai -- the correction hardened into a rule and a memory --> tree\n    tree -- read whole, every session --> ai\n    operator -. calls the stop .-> ai';

const AGENT_DIAGRAM =
    'flowchart TB\n    anchor["Disclose the trust anchor · what is assumed and cannot be verified"]\n    phase["Bind to one phase · investigate discovers and never fixes, action fixes and never discovers"]\n    rank["Rank the claims by verification worth"]\n    calibrate["Calibrate every detector · a known-good it must match, a known-bad it must not"]\n    resolve["Resolve each claim to the observation that would settle it"]\n    gather["Gather from the implementation · never infer"]\n    admissible["Check the phase was honoured"]\n    verify["Classify each claim · verified, contradicted, unverified"]\n    audit["Audit the agent\'s own contract · an overclaim lowers its confidence"]\n    artifact["Emit exactly one typed artifact"]\n    anchor --> phase --> rank --> calibrate --> resolve --> gather --> admissible --> verify --> audit --> artifact\n    verify -. refuted or escalated, bounded .-> resolve';

const CREATION_DIAGRAM =
    'flowchart TB\n    evidence["Inspected domain evidence"]\n    contract["A portable contract · semantic operations and slots, no runtime"]\n    adapter["An adapter renders it for one runtime"]\n    grounded{"Grounded, embodied, no leakage?"}\n    persisted["Persisted, with its participation declared in the body"]\n    evidence --> contract --> adapter --> grounded\n    grounded -- yes --> persisted\n    grounded -- no --> contract';

const HUMAN_SECTION: Section = {
    icon: HUMAN_SECTION_ICON,
    id: HUMAN_SECTION_ID,
    intro: "This section covers how the developer and the model reach each other. You decide what the work is for and the model shapes the work, as described in ask where it appears, and only two things cross between those two roles. A question goes from the model to you, through one channel and with a recommendation first. A correction goes from you to the model once, and hardens into a named rule, as described in rules with names. Everything else, both of you read from the tree, as shown in <cite>two channels</cite>. The same split, with the tooling as the third party, is described in who does what, and the architecture page grounds it in the fact that the author is probabilistic.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "In practice, the developer governs by writing what the work is for and what finished means, and corrects drift immediately and briefly, in a few words, once. The correction is expected to become a rule with a stable name and a memory in the same turn, and the next session is expected to read them. When the developer says something that contradicts the plan, the model is asked to halt, check the tree again, and report what it finds rather than argue about the state of a file. A session runs continuously until the queue is empty, and the developer calls the stop.",
                    boundary:
                        "A question crosses the line only when its answer changes what gets built, and then before the work that depends on it.",
                    cause: "A model tends toward the reply that reads as helpful, and a reply that reads as helpful is often a summary, a pause offered as thoroughness, or a question that could have been a recommendation.",
                    decision:
                        "The line is crossed through the two channels only, a question up and a correction down, rather than through the conversation.",
                    failureMode:
                        "The developer explains the architecture at length, the model reports a milestone and asks what to do next, and the work stops while looking finished.",
                    kind: "lesson",
                    principle:
                        "For this reason the developer governs, the model is asked to work inside the boundaries, and a correction hardens into a rule rather than being repeated.",
                    problem:
                        "Without a declared split, the developer ends up shaping the work by hand and the model ends up guessing what it was for.",
                    validation:
                        "To check this, read a session's transcript for the moments the turn ended. Each should be the developer calling the stop or a question through the channel; anything else is a halt dressed as a report.",
                },
                {
                    kind: "text",
                    text: "The model is asked never to mention, imply or act on how much capacity it has left, because it cannot measure that, and an assumption presented as a constraint cuts the work short on a false premise. Only the developer calls the stop, and the halts that pretend otherwise are described in a turn never ends to wait.",
                },
                {
                    kind: "text",
                    text: "A memory that has gone stale leads to a question rather than a silent refresh, and the order of precedence is set out in three encodings.",
                },
                { caption: "two channels", kind: "mermaid", text: HUMAN_DIAGRAM },
            ],
            title: "Two channels across one line",
        },
    ],
    title: "The developer and the model",
};

const AGENT_SECTION: Section = {
    icon: AGENT_SECTION_ICON,
    id: AGENT_SECTION_ID,
    intro: `An agent that persists across sessions is a walk through the loop, not a persona, as shown in <cite>a verifying agent</cite>. The agent templates on the grammar page are walked rather than adopted, which applies the rule described in a seat is a contract to agents. An agent is created as shown in <cite>making an agent</cite>. Its definition is executed rather than consulted: it directs the agent to disclose what it trusts, bind itself to one phase as phase binding requires, rank what is worth verifying, calibrate its detectors, gather from the implementation, check its own contract against its own behaviour, and emit exactly one typed artifact. The agent that creates agents and the agent that audits them are the same loop applied to agents, and what the walk executes are the ontology's contracts for the ${stage("orient")} and ${stage("verify")} stages.`,
    subsections: [
        {
            blocks: [
                {
                    application:
                        "In practice, an agent is written as a contract the loop can execute. It has a disclosed trust anchor, a phase it binds to, and a ranking of its claims by risk and uncertainty. Every claim has an evidence requirement naming the observation that would settle it, an admissibility check confirms the phase was honoured, and the run ends in a single typed artifact. The agent is generated from inspected evidence about its domain, rendered through an adapter, and shown to be grounded and embodied before it is persisted.",
                    boundary:
                        "A bounded invocation has no channel back, so it returns its uncertainty as described in ask where it appears, and a rule that should have been inverted for it, left as it is, is actively wrong while reading as governed.",
                    cause: "An agent written as a description is applied by its reader's interpretation, and the interpretation drifts with the reader.",
                    decision:
                        "An agent is defined by the loop it walks and the artifact it emits, rather than by a voice.",
                    failureMode:
                        "A reviewer agent with a persuasive system prompt approves a change that reads well, because nothing in its definition made it open the diff, calibrate a detector or name what would refute its verdict.",
                    kind: "lesson",
                    principle:
                        "For this reason I treat a capability as real only once its behaviour matches a testable contract, and a verifier applies its rules to itself.",
                    problem:
                        "An agent defined by a voice can be judged only by how it sounds, and a model can make almost anything sound right.",
                    validation:
                        "To check this, run the agent on a case with a planted contradiction and on a clean case. It should report the contradiction with its evidence and pass the clean case for the right reason; an agent that cannot fail on purpose has never been shown to work.",
                },
                {
                    kind: "text",
                    text: "The anchor is disclosed, as verify the verifier requires, and the self-audit is what catches an overclaim above it: the agent reads its own definition, extracts every capability it claims, runs a positive and a negative case for each, and lowers its confidence for every claim it cannot back.",
                },
                {
                    kind: "text",
                    text: "Phase binding is what keeps an investigation honest. An investigation discovers and never fixes, and its artifact is a report of evidence. An action fixes and never discovers, and its artifact is a log of bounded changes against known evidence. The two exclude each other because the checks that heal rewrite the tree, so an investigation that ran them has changed the tree under a read-only contract.",
                },
                {
                    kind: "text",
                    text: "An agent is generated the way a plan is, from a template that is executed, as described in execute the template. Its source is inspected evidence about the domain it will investigate, never prior knowledge, which is the difference between grounded output and ungrounded content. Its target is a portable contract, the shape the drop-in gives every core, rendered for one runtime through an adapter pattern, so the same agent moves to another runtime by being rendered again. What an agent needs to know in order to act is declared in the body it is delivered with, because a declaration in a field the runtime discards never reaches the agent, and a check reading that field measures an artifact while the mechanism does nothing.",
                },
                { caption: "a verifying agent", kind: "mermaid", text: AGENT_DIAGRAM },
                { caption: "making an agent", kind: "mermaid", text: CREATION_DIAGRAM },
            ],
            title: "A walked loop, one artifact",
        },
    ],
    title: "Agents as executed contracts",
};

export const COORDINATION_SECTIONS: readonly Section[] = [HUMAN_SECTION, AGENT_SECTION];
```