AI agents are good at producing text and getting better at writing code. But the work people actually ask them to do has a different shape: make a quiz, build a spreadsheet, draft a chart, design a form. Those outputs have internal structure, rules, validation, and a lifecycle. Treating them as blobs of generated code throws away the semantics that make the work useful.
Graffiticode gives agents a better target: not code to generate, but task agents that create and maintain artifacts. A Graffiticode language is the precise interface for one kind of work. The client agent delegates. A router maps intent to the right task agent. The task agent authors in that language. The compiler checks. The artifact persists.
A Graffiticode item is a durable identifier. It points to a task, and that task defines an artifact. The item survives revisions while the task source evolves. A task is a program written in a Graffiticode language — it compiles to an artifact that a runtime can render.
Client Agent
▲ │ (delegates intent)
│ ▼
│ Router
│ │ (maps intent to task agent)
│ ▼
│ Task Agent
│ │ (authors and revises in language)
│ ▼
│ Task {language, code}
│ │ (compiles to)
│ ▼
│ Artifact
(returned │ │ (identified by)
to client) │ ▼
└── Item
That is what we mean by an artifact server for AI agents.
TALK TO THE TOOL
Most agents use tools. Graffiticode lets agents talk to them.
In Graffiticode, tools are embodied as task agents. When a client agent delegates to a task agent, it is opening a conversation with a specialist that knows its language and can hold up its end of the exchange. The client agent expresses intent in natural language. The task agent owns the task — it authors code, compiles it to an artifact, and returns an item the client agent can revise or deploy.
That is what makes revision tractable. The client agent delegates and gets an item back. On subsequent turns it passes that item identifier. The task agent retrieves the task, reads the source, and applies a focused change. The item carries the context forward.
The user asks for something. The router selects the right task agent. The task agent authors or revises a task and compiles it to an artifact. The result comes back as a real object, not a regenerated approximation. No domain knowledge leaks upward.
Talk to the tool. Get a thing back that is both production ready and ready to revise.
LANGUAGE IS THE INTERFACE
A Graffiticode language is the interface between the client agent and the artifact. It defines what the client agent can ask for, what the task agent can author, what the compiler will accept, and what the runtime can render. No party has to trust the others — they all trust the language.
A language does not belong to either agent. It sits between them and governs the exchange. A domain like assessments has multiple languages — one for multiple choice, one for concept webs, one for spreadsheet problems. The router selects the right task agent. The client agent only needs to name what it wants.
COMPILERS MAKE AGENTS BETTER
Agents are probabilistic. Compilers are not.
A compiler enforces two kinds of invariants. The language defines what is expressible — the shape of valid tasks, the operations available, the outputs that a runtime can render. The security model defines what is permitted — the capabilities an agent holds, the policies that govern its actions, the grants that bound its authority. The compiler checks both before anything reaches a runtime or produces an effect.
This changes what it means to trust an agent. The model can be flexible at the boundary where human intent enters the system. The compiler is strict at the boundary where the system commits to an artifact or effect. Correctness and safety become properties of the compiled task, not promises from the model that authored it.
The result: outputs are inspectable, validatable, repeatable, and composable. Composition is enforced by language interfaces, not by fragile prompt handoffs. The mechanics of safety are covered in How Graffiticode Keeps Agents Safe.
THE SIMPLE PROMISE
The promise is simple: when an agent makes a thing, that thing should remain a named thing.
Not a screenshot pretending to be a chart. Not a pile of HTML pretending to be a form. Not opaque JSON pretending to be an assessment. Not a regenerated approximation of yesterday’s spreadsheet.
A real artifact has a language. It has a compiler. It has a runtime. It has an identity. It can be inspected, revised, embedded, composed, and trusted.
That is what Graffiticode is for AI agents: the place where intent becomes artifact, and where artifacts can be refined after they are created.