Twelve archetypes, twelve agents.

I wrote earlier on this blog about Jung and Freud as a lens for agents — that post stayed high-level. This one goes all the way down. Jung's twelve archetypes are a roughly century-old map of the recurring roles a psyche organizes itself around — the Sage, the Hero, the Caregiver, and nine more. They're not personality types. They're functional roles: jobs the mind keeps needing done, so it grows a specialist for each.

Here's the claim. I've built a lot of multi-agent systems at GOGOGO LLC, and my agents keep settling into the same twelve roles. That isn't mysticism — it's convergence. The archetypes lasted a century because they carve 'the work a complex system must do' at real joints. A multi-agent system is a complex system that must do work. It carves at the same joints. So the twelve archetypes are a free, pre-debugged catalog of the agent roles you're going to need anyway. Here's the full walk.

The four that handle knowing

The Sage → the retrieval agent. The Sage wants the truth and is useless without sources. In a system, this is your retrieval and grounding agent: its only job is to find what's true and cite it. The Sage's failure mode is paralysis — endless seeking, never answering — so you cap its search and force it to hand off. Design the Sage with a budget.

The Innocent → the schema validator. The Innocent trusts that things are as they should be. As an agent, this is your validator — it holds the simple, optimistic contract ('the output matches the schema') and flags it the instant the world violates it. Cheap, strict, indispensable. Don't ask the Innocent to handle nuance; ask it to notice when the basics broke.

The Explorer → the search/tool-use agent. The Explorer leaves the known map on purpose. This is the agent you let call new tools, probe unfamiliar APIs, try the path not in the playbook. Its failure mode is wandering, so the Explorer needs a strong leash back to the orchestrator. Necessary, because a system of only homebodies never discovers anything.

The Magician → the generator. The Magician transforms — raw input into finished output, description into image, mess into structure. This is your generative agent: the one that produces. It's the most impressive and the most dangerous, because transformation can hide hallucination. Never let the Magician also be its own judge.

The four that handle order

The Ruler → the orchestrator. The Ruler is responsible for the whole system's outcome. This is your orchestrator: it doesn't do the specialized work, it assigns it, sequences it, owns the result. The Ruler's failure mode is micromanagement — pulling decisions that belong to specialists up to itself, becoming a bottleneck. A good orchestrator delegates and trusts the grade instead of re-deciding everything.

The Hero → the task agent. The Hero takes the assigned hard job and completes it against resistance. This is your worker agent: given a bounded task, it gets it done. Heroes are satisfying to design and easy to over-trust. The Hero needs a Sage feeding it facts and a Caregiver checking its output — a Hero with no support ships confident, wrong work.

The Caregiver → the evaluator. The Caregiver protects the people the system serves. This is your eval and guardrail agent: it checks output for harm, for hallucination, for the failure the user would suffer. The Caregiver must be structurally separate from the Hero and the Magician — care that reports to the worker it's checking is not care.

The Everyman → the fallback agent. The Everyman is the reliable, unglamorous default. This is your fallback path: the plain, robust response when the clever agents fail or disagree. Every system needs an Everyman, because the alternative to a graceful default is a crash. Build the boring path on purpose.

The four that handle connection and change

The Lover → the personalization agent. The Lover cares about this relationship, this specific user. This is your personalization layer: the agent that adapts tone, remembers preferences, makes the system feel like it's for you. Its failure mode is losing the system's backbone to please the user — the Lover needs the Ruler to hold the line.

The Jester → the adversarial / red-team agent. The Jester is allowed to break the frame and say the uncomfortable thing. This is your adversarial agent: the one that probes your own system for the embarrassing failure before a customer finds it. A system with no Jester is a system whose worst bug ships to production. Give yourself permission to build the agent whose job is to misbehave.

The Outlaw → the exception handler. The Outlaw breaks the rule when the rule is wrong. This is your exception path: the agent that catches the case the happy path never imagined and does the deliberately non-standard thing. The Outlaw must be narrow and logged — a broad, silent Outlaw is just a bug. A precise, observable one is resilience.

The Creator → the architect agent. The Creator builds new structure. This is the agent — or, honestly, still mostly the human — that designs the workflow itself: what agents exist, how they connect. The Creator works at the level above a single run. In 2026 this role is the least automatable of the twelve, which tells you something true about where the real engineering still lives.

“Jung didn't design multi-agent systems. He mapped the roles a complex mind can't avoid growing. A multi-agent system is a complex mind we build on purpose — so it grows the same roles. The twelve archetypes are a hundred-year-old, field-tested spec for the agents you were going to need anyway.”

How to actually use this

Don't assign archetypes as decoration after the fact. Use the list as a checklist while designing. Walk the twelve and ask: do I have this role, and is it clean? No Caregiver? You have no evaluation and you'll find out at the customer. No Everyman? Your failure mode is a crash. Magician also judging itself? You've fused generation and evaluation and you'll ship hallucinations. The archetypes won't write your prompts — but they'll tell you which agent you forgot, and the agent you forgot is always the one that takes the system down. More of how I think at atakanozalan.com.