It's Thursday evening, you're hunched over a keyboard, looking at your IDE. Cursor has generously written the code you asked for, but now it's waiting for you to run it, test it, and report back. You've seen this movie before. You run the code, see new errors pop up, which you paste back into Cursor to debug. Rinse and repeat.
When I first started using Cursor, this human-agent-human-agent-human loop was painful. I realized I had become a Context Messenger. I was manually stitching together context for Cursor to do its best work. It was like being given keys to a supercar with a speed limiter: you can only go so fast. As the Context Messenger, I was the speed limiter – a bottleneck in the context throughput – severely slowing down Cursor's ability to debug its own code.
The Context Messenger loop exists because the agent's context ends at the codebase. The agentic coding tools available today are extremely intelligent; intelligence is not really a limiting factor for most day-to-day work. The limiting factor is connectivity. By default, everything beyond the codebase – your warehouse or data platform, your source code repository, your project management tool, and your team's knowledge bases – is outside the agent's reach. But it doesn't have to be.
The New Mental Model
Solving the Context Messenger problem requires a shift in thinking.
What an agent actually is
Today, many people still think of agents as code writers. This sort of thinking is limiting. Instead, treat the agent as an actor that can observe and interact with the environment it's put in.
When you onboard a new hire, you don't stop at providing the new hire with access to your codebase. You provide them with documentation. You provide runbooks teaching them how to not only run the code, but to test it, deploy it. You give them access to your systems: your knowledge bases (think Jira, Confluence, Google Drive), your source code repos (think GitHub), cloud platforms (think AWS), and data platforms (think Snowflake), and allow them to observe and interact with these systems.
Coding agents are no different. If their world ends at the codebase, they are severely limited. They need to be connected to your systems so they can interact with them directly without a Context Messenger in the loop.
What done looks like now
My day-to-day work has changed massively in the last 4-6 months. As I'm sure many can relate, I read and review a lot more code now than I write. I think and plan a lot more before jumping straight into a task. Why? Some of the most exciting work I have done in the last couple of months has been around solving the Context Messenger problem for myself and my team. This work has allowed me to delegate several pieces of my day-to-day work to coding agents – while improving the quality of work in many cases – and freeing up my time for high-leverage and more exciting work.
Typical tasks that would take up to an afternoon's worth of work now are compressed into what feels like a half hour. In the past I would jump at the first opportunity to start writing implementation code. Now, I take a step back. Knowing I'm preparing to delegate work to an agent, I create a well-defined Jira item, defining the scope of work, acceptance requirements, and implementation details.
From there, the agent takes over. It reads from Jira, checks out a new branch, plans the build, iterates on the plan, starts doing the work, tests, debugs, and iterates. Once complete, it commits the code and opens a pull request with a well-crafted description. In many cases where human review isn't needed, the agent also takes care of merging a branch to production once CI checks pass.
Debugging data pipeline job failures looks different now too. Instead of manually checking logs and running queries to debug the failure, I delegate the task to an agent. The agent fetches logs from the orchestration layer, runs queries to debug the failure, reads through company knowledge bases to identify any past occurrences, and root causes. What used to be a 30-60 minute task taking away valuable attention in the morning now often takes a few minutes. This is possible because the Context Messenger bottleneck is largely eliminated and the agent can intelligently access several different pieces of the data stack.
Closing Thoughts
Agentic coding tools have come far, and the models keep improving. But you won't benefit from these improvements unless you solve the Context Messenger problem.
If this resonates, I'd love to hear how your team is thinking about this — find me on LinkedIn.