







"What are your overnight agents?"
I asked Pawel Nical this halfway through dinner, after he'd been describing the nine-role system he runs his business on. It was a genuine question. I wanted the mechanics.
He pulled out his phone and showed me the desk. In-tray, out-tray, a whiteboard with a priority matrix, a reflections corner, a library where every artifact the system produces sits on a shelf. There's a basement for the things he's stopped using. Nine roles talk to each other all night. The chief of staff decides what lands on his desk. The PM coordinates everyone else. An art director turns raw material into graphics. A positioning agent knows how he talks because he fed it four and a half million words of his own transcripts.
At 8:30 in the morning he gets a briefing. Here's what we worked on overnight. Here are the twenty items. The designs are on your desk.
It's the most elaborate personal agent system I've seen up close. And at the end of the night, when he showed me the thing he was proudest of, I saw the problem.
He'd asked his AI engineer to draw a picture of how the whole system connects. What context is always on, what's off, how the nine roles relate to each other. He called it his context graph. He drew it because he needed to see his own system.
That's the part that should stop you.
Two years ago the hard part of building an agent was the model. Could it write a decent email, hold a conversation, follow instructions? That got solved fast, and the difficulty moved somewhere else.
Now the hard part is context. Anthropic has a name for it: context engineering, the work of deciding what goes into the model's window and what stays out. It matters more than the model, because a strong model with the wrong context produces a wrong answer with confidence. A weaker model with the right context usually beats it.
Redis published a writeup earlier this year on what happens when agent context fails in production. Four failure modes. The one that sticks with me is fragmentation: an agent that only sees part of the picture rarely returns an error. It returns a confident answer built on a fraction of reality. Their FinanceBench example makes the point sharply. The same model answered 19% of finance questions correctly when it searched one shared vector store. Handed the right evidence page, it answered 85% correctly. Same model, same questions. The only difference was the context it was handed.
This is why everyone running agents in production has quietly stopped arguing about model choice and started arguing about context. Microsoft's Azure SRE team wrote that they began with a hundred tools and fifty specialized agents and ended with five tools and a handful of generalists. The system got more reliable when they started caring about what went into context, when, and in what form.
Anthropic's guidance on multi-agent systems lands the same way: teams over-build. Multiple agents typically use three to ten times more tokens than a single agent for the same work. Most of the extra spend is coordination, duplicated context, and lossy handoffs between roles.
Here's what struck me about Pawel's system. None of the hard-won lessons about context are automated. He built every one of them by hand.
The continuity that keeps his chief of staff from losing the thread? A custom skill that fires at token compaction, writes a summary to a local file, and reloads it next session. He built that.
The positioning agent that knows how he talks? A database of four and a half million words of his own transcripts, codified by hand.
The map of how his nine roles connect? He asked his AI engineer to draw it.
The desk itself does real work. Pawel needs to see his agents the same way his agents need to see his business. The in-tray, the library, the reflections corner all exist because nine roles running unseen overnight is something you trust once and then want to inspect forever.
This is the state of the art in agent operations right now: a handful of very good operators, each rebuilding the same operational layer from scratch, in their own heads, with their own duct tape. The context graph one person draws by hand is the thing the next person hasn't drawn yet. When the operator isn't there to explain the system, the system stops existing for anyone else.
And that's the point that matters for your business. Most teams don't have a Pawel. They have an agent that was handed a system prompt and a few MCP connections and told to be useful. That agent doesn't know how the business runs. It doesn't know what happens before the step it owns or after it. It doesn't know which tool is the source of truth for which field. It doesn't know who approves what. It's operationally blind, and the failure shows up as confident mistakes that take a human to catch.
The fix is to give the agent the same thing you'd give a new hire: a map of how the business works.
When the map exists first, a few things change.
The workflows, the teams that own them, the tools each step runs on, the data each step touches. That's the operational layer an agent needs, and it's the layer missing from almost every deployment today. When it exists as structured, queryable objects, the agent reads it the way a tenured employee reads the org: it knows what's upstream and downstream of its work.
Pawel's context graph lives in his head and on his laptop. Your best agent operator has the same problem. If that person leaves, the agents they built go dark or start making mistakes nobody can trace. A map that lives in the business, shared and maintained, survives the departure.
Anthropic's telephone-game observation is real: every handoff between agents loses fidelity. The fix is a shared reference, a single picture of the operation that every role reads from. The PM agent, the art director, the positioning agent all work from the same map instead of each other's summaries.
What makes agent systems work is a shared operational layer underneath the roles.
Let me be straight about the limits.
A map does not make an agent competent. It removes one class of failure, the blind operation, and leaves the rest intact. A model can still reason poorly, still hallucinate, still take an action it shouldn't.
A map rots too. The reason your onboarding doc went stale is the same reason a blueprint goes stale if nobody maintains it. The difference is structure: a map made of linked objects is easier to keep current than a wall of prose. But the discipline of updating it still belongs to a person, not to the software.
And this is all early. The Model Context Protocol crossed forty-seven thousand registered servers this year, and Stacklok's survey found 41% of software organizations running MCP in production. But "production" for most teams still means a pilot, a Slack bot, a single workflow. The infrastructure for doing this well is younger than most of the agents running on it.
Pawel's system runs from midnight to eight in the morning. He wakes up to a briefing from his chief of staff. Twenty items worked overnight. Designs left on his desk.
What he trusts in that briefing depends entirely on what his agents knew when they started. If they worked from a map of the business, the briefing is grounded. If they worked from a pile of prompts and guesses, the briefing is confident fiction wearing a clean layout.
The overnight shift is coming for a lot of companies. The question worth asking before it arrives is simpler than any architecture decision: when your agents come back at 8 a.m., will they be working from the same map you are?
This is what we build at Puzzle: the operational layer your agents read from. If you want them working from a map instead of a guess, start with the map.
Map your first workflow today. Free to start, no credit card needed.