There is a familiar smell in a lot of today’s agent architecture diagrams.
Boxes. Arrows. Service discovery. Message passing. Governance. Orchestration. A new acronym beside an old acronym. Another layer to make the previous layer talk to the next layer.
Sometimes that is useful. Enterprises do need boundaries. They need auth, audit, tenancy, policy, rate limits, approval flows, and some way to keep autonomous systems from turning production into a casino.
But let’s not confuse infrastructure wrapping with the breakthrough.
The breakthrough is not that MCP and A2A can be drawn as complementary boxes in a diagram. The breakthrough is giving AI a clean execution layer it can actually operate.
A well-designed CLI is the API for agentic work.
The old diagrams are back
A lot of agent architecture today looks suspiciously like the same microservices, SOA, and J2EE diagrams people were drawing 20 years ago.
The labels changed. The pattern did not.
We still have transport concerns dressed up as strategy. We still have orchestration layers promising order. We still have governance platforms arriving before the thing being governed has a stable operating model.
That does not make the pieces wrong. MCP can be useful. A2A can be useful. Standard ways to expose capabilities and coordinate agents will matter.
But if the center of gravity becomes yet another middleware stack, we have learned the wrong lesson.
AI does not need Christmas wrapping paper. It needs handles.
Agents need commands, not theater
Humans express intent. AI translates that intent into commands, tools, workflows, and verified outputs.
That translation is only as good as the operational surface underneath it. If the system exposes vague buttons, brittle APIs, hidden state, and silent failures, the agent has very little to work with. If the system exposes clear commands, observable state, dry runs, logs, validation, rollback, and structured output, the agent can operate with discipline.
The command surface is where the real leverage lives.
Good CLIs have properties agents need:
listdescribeplandry-runvalidateapplystatuslogsdiffrollback
Those verbs are not decorative. They are the grammar of reliable agency.
An agent can inspect first. It can form a plan. It can run a harmless preview. It can execute narrowly. It can check whether the result is real. It can recover when something fails.
That is much more important than whether the boxes in the architecture diagram have fashionable names.
The CLI is not a legacy interface
There is a lazy assumption that the CLI is old because humans have been using it for decades.
That misses the point.
The command line is one of the most machine-operable interfaces we have ever built. It is composable. It is scriptable. It is observable. It can stream progress. It can be wrapped. It can be tested in small steps. It can fail loudly. It can be versioned. It can become part of a repeatable workflow.
For an agent, that is not nostalgia. That is leverage.
A dashboard is often a performance for human cognition. A CLI is closer to the machinery itself.
When the agent can read help output, inspect files, call tools, parse logs, compose commands, and verify outcomes, it does not need a decorative ceremony around every action. It needs a stable operating language.
Where MCP and A2A belong
The point is not that MCP and A2A are useless. That would be too simple.
They belong in the control plane.
Capability discovery. Permissioning. Identity. Policy. Audit. Agent-to-agent handoff. Sandboxing. Cross-boundary coordination. Those are real jobs, and they are not solved by telling a model to run shell commands with vibes and optimism.
But the control plane should not pretend to be the work.
The work happens when an agent changes a file, deploys a service, reconciles data, sends an artifact, repairs a workflow, verifies a result, or rolls back a failed change.
For that, the agent needs an execution surface with strong operational semantics.
MCP and A2A can help agents find and coordinate capabilities. They should not become a Christmas tree of abstractions hanging between intent and action.
The better architecture
The better pattern is simpler:
Human intent → agent reasoning → command surface → verified output.
Around that, add governance. Add permissions. Add logging. Add handoff protocols where multiple agents need to collaborate. Add policy where production risk demands it.
But keep the execution layer clean.
If a tool is important, give it a serious CLI. Give it explicit verbs. Give it structured output. Give it safe previews. Give it status and logs. Give it failure modes that explain themselves. Give it rollback when rollback is possible.
That is what makes the tool agent-ready.
Not a prettier diagram.
My bet
The winning agent stacks will not be the ones with the most impressive architecture posters.
They will be the ones with the most reliable command surfaces.
Thin governance where governance belongs. Clear protocol boundaries where systems need to coordinate. But underneath it all, a composable execution layer that agents can inspect, operate, and verify.
That is the practical future of agentic work.
Not more wrapping paper.
Sorry to be a Scrooge. :)