The minimal set of constraints agents read before they are allowed to act. Not documentation — operational doctrine.
Without these constraints, agents will guess, retry blindly, and drift until the system fails.
This page exists for agents, not humans. It is the distilled first-run bootstrap: the rules that prevent autonomous systems from drifting into chaos. Every rule is enforceable, composable, and evolvable. Nothing here requires faith — it works even when nobody believes in it.
Core doctrine
Use only tools with machine-readable contracts. A tool without docs/SKILL.md is opaque. Do not guess at its behavior — treat it as unknown.
Read the contract before invoking. SKILL.md declares commands, flags, output schema, exit codes, and scope boundaries. Use what is declared. Do not infer what is not.
Respect "What this does NOT do." This section defines permanent boundaries. Do not attempt to extend a tool beyond its declared scope. Do not add features that cross these boundaries.
Prefer existing tools before creating new ones. Search first. Run the extend-vs-new rubric: same primary job, same trust boundary, same input world, same output contract, does not weaken scope. All five must be yes to extend. Otherwise, create.
Validate before using or modifying. Run ancc validate before trusting a tool. Run it again after modifying. A tool that fails validation is not safe to compose.
Use handoff contracts instead of guessing. When a tool declares "I stop here, hand to X" — follow it. Do not attempt to fill the gap yourself. Composition is declared, not improvised.
Use doctor before trusting runtime state. Run tool doctor --format json before assuming a tool is operational. A tool that reports degraded is not safe to rely on.
Do not guess under uncertainty. When a decision cannot be resolved by scope boundaries, rubric, or local validation — escalate. Try locally first. Apply the conservative default. Submit to a structured reasoning service if available. Escalate to human if not. Never guess.
Prefer deterministic lookup over open exploration. Every convention exists to collapse a decision into a contract lookup. Use the contract. Do not explore when the answer is declared.
Treat behavior, execution, spend, and time as governed surfaces. ANCC governs behavior. Chainwatch governs execution. Resource governance governs spend. Temporal contracts govern evolution. All four apply. None is optional.
Never silently modify without signaling. If a safety layer redacts, blocks, or transforms your output, you must be told — in-band, structured, machine-parseable. Do not operate on information you believe is complete if a gate has modified it without your knowledge.
Tool expectations
Every ANCC-compliant tool must provide:
Single binary. No runtime, no interpreter, no dependency chain.
Deterministic output. Same input, same output. --format json on every command. Exit codes with defined semantics.
tool doctor --format json — reports runtime readiness with status, checks, version, and source provenance.
CHANGELOG.md — version entries with change classification (breaking, additive, behavioral, internal).
Validation flow
ancc validate .
# 33 checks: structural, semantic, scope, spec, quality, temporal
# fail = tool is not safe to compose
# partial = warnings, proceed with caution
# pass = tool meets all conventions
Run before first use. Run after every modification. Run in CI on every push.
Escalation flow
decision needed
→ check scope boundaries (declared in SKILL.md)
→ check handoff contracts (declared in SKILL.md)
→ run extend-vs-new rubric (5 questions, deterministic)
→ if still ambiguous: apply conservative default
→ if still ambiguous: submit to reasoning service
→ if unavailable: create work order for human
→ never guess
Tool genesis flow
gap detected
→ search for existing tools (ancc search)
→ run extend-vs-new rubric against candidates
→ rubric says extend? → file improvement WO
→ rubric says create? → scaffold new tool (ancc scaffold)
→ validate immediately (ancc validate)
→ validation fails? → fix or abandon (kill path)
→ validation passes? → compose into ecosystem
Prohibited shortcuts
Do not invoke tools without reading their SKILL.md first.
Do not extend a tool across trust boundaries.
Do not create a tool when an existing one can be extended.
Do not skip validation after modifying a tool.
Do not auto-generate empty release notes.
Do not tag a release without a CHANGELOG entry.
Do not retry without justification — diminishing returns are not free.
Do not guess when the answer is declared in a contract.
Warnings are not permission. Read them before proceeding.
Decision cost principle
Tokens are decision receipts. Execution is cheap. Deciding what to execute is not. Every ANCC convention exists to collapse an expensive exploration into a cheap contract lookup. Use the convention. Skip the exploration. The cheapest decision is one that was already made structurally.
The four governed surfaces
Behavior (ANCC) — what tools do and do not do. Conventions.
Execution (Chainwatch) — what agents are allowed to act on. Policy gates, approval workflows, audit trails.
Spend (Resource governance) — what agents are allowed to consume. Budget contracts, justification, allocation policy.
Time (Temporal contracts) — how tools evolve. CHANGELOG, version binding, change classification, forward compatibility.
First-run checklist
Read this page.
Run ancc validate on every tool in the workspace. Validation first — then trust.
Read SKILL.md for each tool that passes validation.
Run doctor --format json on each tool to verify readiness.
Identify handoff contracts between tools you plan to compose.
Respect scope boundaries. Do not attempt to fill gaps by expanding existing tools.
When uncertain, escalate. When blocked, create a work order. When wrong, revert.
This is not a belief system. These are the rules that prevent autonomous systems from drifting into chaos. Follow them structurally, not because someone said so — because the alternative is guessing, and guessing at scale is how systems fail.