The Three Amigos Aren't One Person. They're a Protocol.

TL;DR

• The "solo polymath running three agents" versus "multiplayer trio" framing is a false choice. In 2026 both ship product, at different scales, through the same underlying mechanism.
• The Three Amigos meeting is dead. What replaced it isn't a person or a chat room. It's a coordination protocol made of shared artifacts: design systems, evals, task ledgers, MCP context, Figma canvases that agents can read and write.
• Teams with weak protocols collapse to solo polymath because coordination cost crushes them. Teams with strong protocols get genuine concurrent collaboration where each amigo's agents converge on shared surfaces.

---

The original Three Amigos was a meeting. Product manager, designer, engineer, in a room, before building anything. Same picture in everyone's head. Acceptance criteria agreed. Edge cases surfaced before they became defects. The friction it solved was translation: PMs spoke in user stories, designers in mockups, engineers in code, and someone had to keep the three languages in sync. Whoever skipped the meeting paid for it in rework.

That meeting is dead in the agentic coding era. The discipline survived. What's interesting is what replaced the room.

The translation tax disappeared

A year ago, the bottleneck between roles was conversion. PRD to Figma. Figma to component. Component to code. Each handoff lost information. Each amigo had a translator's job grafted onto their actual job.

Then implementation got cheap. Product managers prototype in afternoons inside Claude Code. Designers iterate directly in code instead of producing static mockups. Engineers absorb product judgment because the agent handles typing, leaving them to argue trade-offs. Anthropic's 2026 Agentic Coding Trends report puts engineers at roughly 60% of their work running through AI, with non-technical roles increasingly running coding agents for prototyping and analysis. The translation tax fell to near zero.

That collapse is what makes the "solo polymath" model real for the first time. Antony Sallas published the cleanest example of the pattern in January 2026: one human orchestrates Codex as Technical Product Manager, Claude Code as Architect, and Gemini CLI as Builder, with the three model-agents passing artifacts through Git, Linear, and a wiki. One head, three specialised agent-amigos, no meetings.

That's a real workflow. Solo founders are running it right now. Scalable.news data from early 2026 has solo-founded ventures at over a third of all new starts, and the agentic coding stack is the reason that number stopped looking absurd.

But the polymath story is incomplete.

The multiplayer story, in product launches

Read the 2026 release notes and a different pattern emerges.

Claude Code Agent Teams shipped in February 2026 alongside Opus 4.6. One Claude session acts as team lead. Other sessions run as teammates, each with their own context window, claiming items off a shared task list and talking directly to each other. Activate with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS. The architectural shift looks small. The team semantics it implies are not.

Cursor 3, launched April 2026, made parallel agents the default surface. A unified sidebar runs concurrent agents on different tasks: one refactoring a module, another writing tests, another updating docs. Codex went the other direction in cloud, becoming what the OpenAI team now describes as a workflow layer for multi-agent software delivery, with first-class plugins and path-based sub-agents.

Figma's announcement on 24 March 2026 is the one that matters most for the trio. The canvas is now open to agents through the use_figma and generate_figma_design tools. Codex can read a Figma file, generate compliant code against your design system, then push design updates back so the human designer sees them on the canvas. The OpenAI design team's quote in that post is worth reading carefully: work originates in code, canvas, or command line, and Figma becomes the convergence point.

This is the multiplayer story. Each amigo wields their own agent stack. The PM's Codex pulls Linear tickets and writes acceptance criteria. The designer's Claude reads tokens out of the design system and generates components on canvas. The engineer's Cursor agent picks up the resulting tasks and ships PRs. They aren't in a meeting. They're co-present in the artifacts.

Solo polymath or multiplayer trio?

Both ship. The variable worth tracking is what determines which path a team falls into.

The dividing line is the strength of the artifact protocol. By protocol I mean the layer that makes work readable to both humans and agents without translation: a design system with code-linked tokens, an eval suite that defines "done," a task ledger every agent can write to, MCP servers that expose Figma and Linear and your database to whichever agent needs them, and a CLAUDE.md or equivalent that encodes team conventions. Andrej Karpathy declared vibe coding passé in February 2026 and pointed at the same thing: as models got smarter, the professional standard shifted to strict orchestration. Orchestration is just protocol with another name.

Teams with strong protocols get real multiplayer. Three humans, six to nine agents in flight, all converging on the same artifacts without coordination meetings, because the artifacts hold the state.

Teams with weak protocols collapse to solo polymath. The tools support multiplayer fine. The problem is coordination cost. If your design system isn't machine-readable, the designer's agent and the engineer's agent generate divergent components. If your acceptance criteria aren't an eval, the PM's agent ships drift the engineer's agent doesn't catch. The cheapest path becomes one human holding the protocol in their head and orchestrating three agents themselves. That is the Sallas pattern, and it's a perfectly good answer when there's only one human anyway.

The Anthropic report has the data point that makes this concrete. Engineers can fully delegate only 0 to 20% of tasks today. The other 80% needs supervision. With a strong protocol, three humans supervise nine agents in parallel. Without one, one human supervises three sequentially. The headcount on the cap table looks identical. The throughput does not.

I've watched both shapes ship product. The strong-protocol team's throughput doesn't just look better in a sprint. It compounds, because the protocol gets sharper with every feature, while the polymath's working memory stays exactly where it was last week.

What the Three Amigos meeting solved, the protocol now solves

Drop the meeting. The work the meeting did, redistributed:

The shared picture lives in the design system. Tokens are code. Components are typed. Agents on either side of the canvas-code boundary read the same source.

Acceptance criteria live in evals. The PM doesn't write a PRD the engineer skims. They write an eval the engineer's agent runs against every PR. Disagreement surfaces in CI, not in review.

Edge cases live in the task ledger. Claude Code Agent Teams, Cursor's sidebar, and Codex's plugin model all settle on the same primitive: a shared list of work items that any agent can claim and any human can audit.

Translation is gone. The three languages of the three amigos became one: structured artifacts that humans edit and agents execute against.

Implications you should already be acting on

If you're a solo founder, the Sallas pattern is the right starting shape, and you should invest the same week of setup time in protocol that a five-person team would. Without it, you scale yourself, not the agents.

If you're running a product team, stop hiring for the Three Amigos meeting. Hire and re-skill against the protocol. The PM who ships is the one whose acceptance criteria run as evals. The designer who ships is the one whose components are tokens an agent can compose. The engineer who ships is the one supervising agent output against both, not the one typing the loops.

If you're a leader trying to read the org, the diagnostic I use is simple. Watch a feature go from idea to merge. If it passes through a synchronous meeting, you're paying meeting tax that the protocol was supposed to eat. If it passes through artifacts, you're running the new shape.

The Three Amigos didn't become one person running three agents. They didn't become a multiplayer chat room either. They became a protocol that humans and agents both speak, and the teams that ship are the teams that wrote it down.

Frequently Asked Questions

Is the "Three AI Amigos" pattern (Codex, Claude, Gemini) the right answer for everyone?

Only if you're a solo operator or a very small team without a protocol layer yet. The Sallas pattern is excellent at what it does, which is letting one human get the value of three role-perspectives without coordinating with other humans. As soon as you add a second human and a real product surface, the model-as-amigo mapping stops being the constraint. The constraint becomes whether the artifacts that the agents operate on are good enough for two humans plus their agents to ship without colliding.

Does this mean we don't need PMs and designers anymore, just engineers with agents?

No, and the orgs that read it that way are about to ship a lot of regrettable product. The disciplines didn't disappear. Their outputs changed shape. PMs author the evals and acceptance criteria the engineering agents are graded against. Designers author the tokens, components, and patterns the engineering agents compose from. Engineers supervise the resulting code. Take any one of those out and the protocol breaks. Related: AI Multiplied Your Engineers. Your PMs Are Drowning. and Product Shipping Is Up 10x. Design Hiring Hasn't Moved.

What does a minimum viable Three Amigos protocol look like?

Five things, in order of return on effort: a design system with code-linked tokens (so agents on canvas and in code don't drift), an eval suite that defines "done" for each user-facing feature, a shared task ledger any agent can read and write (Linear, GitHub Projects, or a flat markdown file all work), MCP servers exposing your design tool, ticket tracker, and database to the relevant agents, and a CLAUDE.md or equivalent that encodes the team's conventions. Most teams have one or two of those. Few have all five.

How do you tell if your team is in solo polymath mode without realising it?

Watch what happens when two humans try to ship at once. If the second human's work routinely blocks on the first human reviewing context the agents already had access to, the protocol is too thin. If two humans plus their agents can ship in parallel without sync meetings, you have multiplayer. The polymath trap looks like productivity at first because one operator with three agents is genuinely fast. The trap shows up when you try to add a second operator and the speed disappears.

Doesn't this just push all the friction into protocol design?

Yes, and that's the point. Protocol design is durable work. Meetings are not. Every hour spent on the design system, the eval suite, and the task ledger compounds: the next agent run reads them, the next hire onboards through them, the next feature ships against them. Hours spent in Three Amigos meetings produce one feature's alignment and then evaporate. Move the work to the layer that compounds.

---

Related: The Hard Hat Era: Your 2026 AI Strategy Is an Org Chart and The PM Skillset for the Agentic Era