Agents use tools. Agents improve tools. Both assume the tool already exists. The third mode is different: an agent hits a gap in its workflow, determines no existing tool covers it, and creates one from zero. The tool emerges from the work, not before it.
This changes what tools are. They are no longer pre-built infrastructure provisioned by humans. They are runtime artifacts of work — born from a specific operational need, shaped by conventions, and governed from the moment they exist.
Observe. An agent encounters infrastructure state it cannot act on. A signal is missing, an output format is wrong, a domain has no structured tool at all.
Identify gap. The agent checks existing tools. Can any be extended? The extend-vs-new rubric answers: does this strengthen the same primary job, use the same trust boundary, the same input world, the same output contract? Does it weaken scope boundaries? If any answer is no — this is a new tool, not a feature.
Create. ancc init scaffolds the binary: SKILL.md, doctor command, structured output, scope boundaries. The agent fills the template — not from imagination, but from the specific gap it just encountered.
Validate. ancc validate runs 30 checks before the tool enters the ecosystem. Not-do sections must have boundary verbs. Commands must not overlap with existing tools. Handoff contracts must declare what the tool refuses. The tool is born compliant or it is not born.
Reject or proceed. The kill path. Validation may reveal the gap is already covered — an existing tool's handoff contract routes to this domain, or a neighboring tool's scope could be extended. If so, the agent abandons genesis and files an improvement WO instead. Most gaps do not deserve a new tool. The rubric exists to prevent the agent from creating one anyway.
Use. The agent uses the new tool for the task that created the need. The tool's first consumer is its author. If the tool cannot solve its originating problem, it fails immediately — no drift, no accumulation of unused tooling.
Compose. Other agents read the tool's SKILL.md and understand its contract. Handoff contracts declare where it fits in the chain. The ecosystem gains a new node — not bolted on, but grown into the topology through the same contracts everything else uses.
Govern. The governance agent runs ancc validate on every new tool. Scope pressure is monitored. If the tool begins absorbing adjacent concerns, a binding directive fires. The tool is subject to the same evolutionary constraints as everything else — from its first commit.
When a human writes a tool, conventions are helpful. When an agent writes a tool, conventions are load-bearing.
An agent optimizes locally — fastest path to solving the immediate problem. Without structural constraints, that optimization produces tools with vague scope, overlapping capabilities, inconsistent output, and no handoff contracts. Multiply by autonomous creation and the ecosystem fills with noise in hours.
ANCC prevents this structurally:
Autonomous tool creation without constraints is a package registry with no curation — npm-scale sprawl, but generated by machines and unattended.
The failure modes are specific:
Every guard in the conventions exists for the human-authored case. In the agent-authored case, those guards are not recommendations — they are the immune system.
ancc init is not onboarding for humans. It is the bootstrap for agent-authored tools — the moment where conventions are injected into the creation process before any code exists.
The "What this does NOT do" section is not documentation discipline. It is the only structural guard preventing an agent from creating 50 garbage tools in an afternoon — each slightly overlapping, each locally optimal, each globally incoherent.
The extend-vs-new rubric is not a style guide. It is the decision gate between growing the ecosystem and polluting it.
The governance loop is not optional overhead. It is the immune system for an ecosystem where tools appear autonomously.
The loop above describes the mechanism — how a tool gets created. But there is a deeper dynamic: why the ecosystem keeps growing.
The primitive: limitation → gap → tool → capability → new limitation. Repeat.
Every tool the system creates expands what it can do. That expansion reveals new edges — situations the system can now almost handle but not quite. Those edges become the next limitations. The cycle continues.
This means capability is not a feature list. Capability is accumulated validated solutions to encountered limitations. The word "validated" is load-bearing. Without it, you are describing cancer — uncontrolled growth that fills every gap with noise. With it, you are describing an ecosystem where only solutions that pass 30 checks, respect scope boundaries, and survive governance become permanent capability.
The system does not grow by adding features. It grows by solving constraints. And only validated solutions persist.
System cognition provides the observation that triggers genesis. An agent cannot identify a gap it cannot see.
ANCC spec defines what a valid tool looks like. Every agent-authored tool must pass the same six requirements as a human-authored one.
Tool genesis is how tools come into existence. Not designed upfront. Not requested through a backlog. Created at the point of need, under full constraint.
Agent ecology is what happens after. The new tool enters the ecosystem, discovers its niche, composes through handoffs, and evolves under governance.
The four layers: legibility → contracts → genesis → ecology. Each requires the one below it.
deployscope, the Pulse monitors, chainwatch, the Spectre scanners — these are not the ecosystem. They are instances of this loop. The ecosystem is the loop itself: observe, identify, create, validate, compose, govern. The tools are artifacts. The loop is the architecture.