Pair a human with an AI and you get one of two creatures.
A centaur has a human head on a tireless body. You decide what to do, and the machine does the running. A minotaur has the bull's head on a human body. The machine decides, and a person carries it out.
People ask which one is more powerful as if it were a matchup. It's more useful to treat it as a question about where the hard part of a task lives, and that answer changes over time. I run a studio on a centaur: one architect directing a swarm of agents and an autonomous daemon. Over the last year I watched pieces of it turn into a minotaur, one reasonable handoff at a time. This post is about how that happens and how to decide on purpose which way each decision faces.
The Centaur Had a Golden Age
The strongest evidence for the centaur comes from chess. In 2005 the PAL/CSS Freestyle tournament let anyone enter with any mix of humans and computers. Grandmasters entered with engines. So did dedicated chess machines. The winner was a team called ZackS: Steven Cramton and Zackary Stephen, two American amateurs rated under 1700, running three computers.
They didn't out-calculate anyone. The engines did the calculating. What they had was a better process: they knew when to trust which engine, when the engines disagreed, and when a position needed a longer look. The humans contributed judgment about the machines, and that was enough to beat far stronger players who also had engines.
That result is why "centaur" became the optimistic word for human-AI teaming. Human judgment plus machine execution beat either one alone.
The part that gets told less often is what happened next. Engines kept improving. Every improvement shrank the set of positions where a human override helped, and grew the set where it hurt. The centaur's advantage was real, and it came with an expiry date set by the machine's rate of improvement.
A centaur is stronger only while the human's judgment adds something the AI's lacks. When the machine's judgment catches up in a domain, the human in the loop turns from an asset into latency, and the arrangement starts sliding toward the other shape whether anyone chooses it or not.
The Minotaur Is Already Here
Cory Doctorow has a name for the other shape: the reverse centaur , a person used as an appendage by a machine. I call it a minotaur because it reads more cleanly, and because in the myth the thing in the maze eats people.
You don't have to imagine one. A warehouse picker whose route, pace, and next item come from an optimizer is a minotaur. So is a delivery driver dispatched turn by turn, and a support agent reading a script a model chose for this caller. The machine holds the decision. The person supplies hands, legs, a legal identity, and a face.
The minotaur has one decisive strength: it scales on the brain side. One model can direct ten thousand people at once. A centaur is capped by the attention of the human at the top, and human attention doesn't parallelize.
It also has three structural weaknesses, and they are the ones that matter for anyone building agent systems.
Nobody catches the mistake
The human executing a minotaur's decision usually doesn't know why it was made. That means they can't tell a good instruction from a bad one. A centaur's body can fail loudly (the code doesn't compile, the test goes red). A minotaur's body carries out a wrong decision faithfully and at full speed.
Accountability splits in two
The party that decided can't be held responsible, and the party that acted didn't decide. Every incident review in a minotaur system ends in the same unsatisfying place: the model recommended it, and the person followed the process.
Judgment atrophies
Treat people as actuators long enough and they stop exercising the judgment that was the only thing they offered over a robot. The minotaur makes itself more brittle over time, because it trains away its own error-correction.
So Which One Is More Powerful?
It depends on what you mean by power, so here is the comparison laid out by dimension.
| Dimension | Centaur (human brain, AI body) | Minotaur (AI brain, human body) |
|---|---|---|
| Throughput | Capped by one human's attention | Scales with the model |
| Ambiguous goals | Strong: a human can answer "should we?" | Weak: optimizes whatever it was pointed at |
| Physical and social work | Weak until robots and agents can do it | Strong: people are the body |
| Error correction | The human reviews what the AI produced | The human rarely has the context to object |
| Accountability | Clear: the decider answers for it | Split between decider and doer |
| Trend as models improve | Shrinks domain by domain | Grows domain by domain |
My answer:
- For raw throughput, the minotaur wins , and the gap widens every model generation.
- For power you can steer and trust, the centaur wins. Only a human brain on top can decide what the system should want, and only a human can answer for it.
- What most organizations will actually run is a hybrid : the AI decides whatever can be checked, and the human keeps whatever needs a goal or a signature.
The hybrid is fine. The danger is how you arrive at it.
How My Centaur Grew Horns
DCYFR Labs started as a textbook centaur. I prompted an assistant, read what it produced, and decided what shipped. That's the workflow I wrote up in AI Assistants as Development Partners.
Then came the daemon, described in Autonomous AI Agents. It runs on a schedule with nobody watching: it observes the workspace, triages what it sees, decides what's worth doing, acts on a bounded slice, and records what happened. The moment it started choosing its own tasks, the direction of control flipped for that slice of work. I stopped setting the goal and started reviewing the output of a goal the daemon picked.
Every handoff after that was locally sensible:
- Self-healing. When a service goes down, a remediation playbook can restart it. Deciding "is this service unhealthy, and is this the right fix?" moved from me to the machine.
- Self-limiting. A metacognition circuit-breaker watches the daemon's own cycles and blocks a task after six unproductive attempts. The AI is now judging whether the AI is wasting its time.
- Self-quarantine. The service watchdog restarts a failed process at most three times an hour, then quarantines it and escalates. The machine decides when to stop trying.
None of those were bad calls. Each one removed toil I was glad to lose. Taken together, though, they describe a system where the machine increasingly decides and I increasingly approve. The morning review, where I read what the daemon did overnight and approve what it hands up, is the minotaur shape at small scale: the goal came from the machine, and the signature comes from me.
No one decides to build a minotaur. It accumulates. Each handoff is small, saves real time, and passes review on its own merits. The shape of the whole system is never on the agenda, so it changes without anyone approving the change. If you only evaluate handoffs one at a time, you will end up with whatever shape those handoffs add up to.
Handing Off Decisions on Purpose
I don't want to reverse the drift. The daemon is valuable exactly because it decides things I shouldn't spend attention on. What I want is for every handoff to be a decision, made with evidence, that I can revisit.
Three rules came out of that.
Graduate on evidence, never on convenience
Remediation playbooks in my stack don't start with authority. A new playbook runs in shadow mode: it reports what it would have done, and a human does the real thing. It graduates to auto only after ten real successes. That is a decision handed from human to machine on a track record, with a paper trail. It's the opposite of drift.
Keep the off switch on the human side
Every autonomous path honors a kill switch that I control and the machine can't override, which I covered in Kill Switches for Autonomous Agents. A minotaur you can switch off is a tool. A minotaur you can't switch off is in charge.
Keep goal-setting and accountability in the same place
This is the rule that matters most. The daemon may pick which maintenance task to do next. It does not pick what the studio is for, what ships to customers, or what gets said in my name. Anything I will have to answer for, I decide.
The Four-Question Audit
Here's the check I now run over my own stack. List the recurring decisions in your system (what gets built, what gets fixed, what gets merged, what gets sent) and answer four questions for each.
- Who sets the goal? Which party decided this was worth doing at all?
- Who executes? Which party does the work?
- Who can catch a mistake? Does anyone in the loop have enough context to say "this is wrong" before it lands?
- Who answers for it? When it goes wrong, whose name is on the incident?
Then read the answers across:
- Human sets the goal, human answers for it: a centaur. Healthy.
- AI sets the goal, AI's output is checked by a system, a human answers for failures of the system: a deliberate minotaur. Fine, if it earned that authority on evidence and has an off switch.
- AI sets the goal, a human answers for it, and nobody in between has the context to object: an accidental minotaur. That row is the one to fix.
The third row is common, and it's easy to miss because it looks like human oversight. There's a human in the loop. They approve every run. But they approve things they didn't choose and can't evaluate, which puts their name on the decision without giving them any real control over it.
The Answer
The minotaur is more powerful in the sense that it scales, and it's gaining ground every time a model gets better at judgment in some domain. The centaur is more powerful in the sense that it can be steered and held to account. Chess showed that the centaur's edge doesn't last forever. My bet is that it lasts longest in domains where "what should we want?" is the hard question.
- Put each party where it's comparatively strong. Machines on what can be checked; people on goals and signatures.
- Expect the balance to move. Every model generation hands the machine another domain.
- Make every handoff a decision. Shadow first, graduate on evidence, keep the off switch.
- Keep goal and accountability together. If you answer for it, you decide it.
The creature you end up with matters less than whether you chose it.
What does your stack look like when you run the audit? Tell me which row surprised you. The accidental minotaurs are where the interesting failures live.
Top comments (0)