I build production enterprise AI systems for Fortune 100 companies.
The model was never the hard part.
Gartner says agentic AI puts $234 billion of enterprise application spending at risk by 2030. The money doesn't disappear, it changes hands and changes shape. Here is the new thing the winners compete on, and the unit that captures it.
Generation is becoming cheap. The durable advantage is the system that detects error, attributes it, and learns from it.
A vault protects storage, not trust. The secret is not the unit of risk; the action it permits is. A practitioner's map of what actually reduces an agent's blast radius, and what nobody has solved yet.
If both human and machine are thin, biased minds whose errors correlate by construction, the value was never oversight but composition: arranging correctors that go dark in different places so the same mistake isn't broadcast twice.
The engine behind today's AI and the leading theory of consciousness break at the same undescribed part, the workspace, which is evidence of shared constraints, not shared experience.
Working memory suggests the conscious self isn't the whole mind but a small, constrained access layer: the narrow beam where a few selected states become reportable and usable.
The missing skill in AI-built software isn't syntax. It's failure literacy: knowing what can break before users discover it.
Getting better at agents is not watching less. It is relocating your checkpoints into the harness and deleting the ones that relocation made redundant.
MCP's 2026-07-28 release candidate removes sessions from the protocol. That reads like an argument against persistent agents. It's the opposite: the session that matters was never the protocol's job to hold.
A five-layer setup for running long-lived agent sessions you can reach from your phone: persistent Zellij sessions under systemd, a self-healing Claude Code launcher, Remote Control, zellij web, and a tunnel with the WebSocket gotcha that bites everyone.
MCP is how agent capabilities travel. It should not be where your operating knowledge lives. For personal agents, the durable leverage is owning the action layer: an operations layer of CLI verbs with stable contracts, progressive discovery, honest errors, and one interface every caller can reuse.
Consciousness is not usually the first mover in moment-to-moment choice. It is a late-binding narrative control layer that converts action into reasons, reasons into identity, and identity into constraints on future action. Locally late. Globally causal.
DORA says the AI productivity dip lasts three months. Telemetry says twelve. That one input swings ROI by $9.9M for a 500-person org. And the curve does not resolve the same way for everyone.
2026 is the year the agent protocol stack started to look real. MCP, A2A, ACP, and AGNTCY define how agents communicate. None of them define what a persistent agent is at the infrastructure layer.
MCP won. In roughly a year, Model Context Protocol went from a clever interoperability idea to the default tool-connectivity layer for AI agents. That makes this a strange time to argue that many agent systems should use MCP less.
The .env file is a collaboration tool for human engineers. It was never meant to be a security primitive. When you run an always-on agent fleet, that distinction stops being theoretical.
Enterprise AI projects don't fail because organizations lack information. They fail because that information exists in a form no system can reliably act on. Curio is built to fix that.
Every agent platform shipping today treats a model call as a request: short-lived, stateless, RPC. Real agents have memory, in-flight tool calls, and partial plans. The request model makes you rebuild context on every call. Sessions are the unit.
Multi-agent systems don't fail because the agents are stupid. They fail because the coordination cost wasn't budgeted for. Identity, overlap, governance, and audit are taxes that compound silently until you get an incident.
Several persistent Claude Code sessions, scoped to different domains, coordinating through EdgePlane. Here's what it looks like in practice.
Every serious attempt to build a multi-agent system converges on the same shape. Then you try to run two workers in parallel, and everything breaks.