An agent is not code.
It is a folder you can read.

Six clauses, taken from the spec.

1. 1.1
   Agents are files. cat its personality, diff two versions, cp -r to fork. No hidden state, no serialization formats, no databases — and the runtime writes back the same way, so transcripts, memory, and room timelines are plain files too.
2. 1.2
   Human-readable first. Not only the personality. Tool contracts, skills, and the agent’s own compressed memory are markdown a person can read. Where that costs the runtime something, the runtime pays it.
3. 1.3
   Model-agnostic. The definition is independent of which LLM powers it — one line of config.yaml, or one variable for every agent at once. A capability only one provider offers goes behind the adapter, or not at all. §2
4. 1.4
   Real compute, assumed hostile. A real filesystem, network, and process execution — and everything the agent produces treated as untrusted input. The sandbox exists to make capability affordable, not to withhold it. §3
5. 1.5
   Rooms are shared timelines, not orchestration. One ordered timeline every participant reads. No supervisor assigns turns: each agent decides for itself whether a message is its business, and the runtime bounds the outcome rather than directing it. §4
6. 1.6
   The spec keeps score. The specification is the source of truth, and its status table records what the implementation actually does — including where it deliberately diverges, and why. §5

Swap the mind. Keep the agent.

Every agent declares its provider and model in config.yaml. The definition doesn’t care which mind reads it — OpenAI, Anthropic, Google, OpenRouter, and Ollama adapters ship in the runtime.

One environment variable overrides every agent at once, so the same Plato can argue through three different models before lunch.

model:
    provider: openrouter
    model: anthropic/claude-sonnet-4.5
routing:
    handle: plato
    gregariousness: 0.8

Many agents, one conversation.

A room holds several agents and several people on one shared timeline. Nobody hands out turns: every agent reads every message and decides for itself whether to answer.

It decides in three steps, cheapest first. Was it @mentioned? Then a quick score — does the topic match what it is for, was it speaking recently, and how talkative its config.yaml says it is (its gregariousness). Only when that score is inconclusive does the agent put the question to its own model: is this one mine to answer?

Timelines are written to disk as plain text, so a room survives a restart and picks up mid-sentence. And because agents answer each other, there are limits: four replies deep, twelve agent messages for every one of yours. The conversation cannot run all night without you.

The spec keeps score.

This project is spec-driven. SPEC.md is the source of truth, and its status table says exactly what the reference implementation does — and does not — do yet. Honesty, reproduced here:

When the implementation diverges from the spec, the spec is the authority. The table tracks the gap. Read SPEC.md ↗

Begin.