According to VentureBeat, the emerging frontier in enterprise AI is agentic coding, where AI systems plan, execute, and iterate on code changes autonomously, moving beyond simple autocomplete. However, most enterprise deployments of these “AI agents that code” are underperforming, and the primary limiting factor is no longer the AI model itself. The core problem is a lack of context—the structure, history, and intent surrounding the code—which creates a systems design challenge for the environment these agents operate in. Research, including work on dynamic action re-sampling, shows agents that can branch and revise decisions perform better, and platforms like GitHub are building orchestration tools like Copilot Agent and Agent HQ. Despite this, a randomized control study this year found developers using AI in unchanged workflows actually completed tasks more slowly due to verification and rework.
The Context Problem
Here’s the thing: an AI agent without proper context is basically guessing. It might produce syntactically correct code that’s completely disconnected from your codebase’s architecture, dependencies, or conventions. The article argues the goal isn’t to shove more tokens into the model, but to engineer what information the agent sees, when it sees it, and in what format. Successful teams treat context as an engineering surface. They build tooling to manage the agent’s “working memory”—deciding what gets persisted, summarized, or discarded across tasks. They’re making the specification a first-class, reviewable artifact, not just a chat history. This turns the messy problem of context into something you can actually design and control.
Workflow or Friction?
But you can’t just engineer context and call it a day. You have to rebuild the workflow around the agent. Think about it: if you drop an autonomous coder into your existing PR process without change, what happens? Your engineers will spend all their time verifying and fixing its output, which is slower than just writing it themselves. As noted in McKinsey’s 2025 report, real gains come from rethinking the process itself, not layering AI on top of a broken one. Agents amplify what’s already good. They thrive in codebases that are modular, well-tested, and documented. In a monolithic spaghetti code jungle? Autonomy just creates chaos.
The New Governance Challenge
This also flips security and governance on its head. An AI can introduce unvetted dependencies, license issues, or code that slips past review. So, mature teams are starting to integrate agents directly into CI/CD pipelines, treating them like any other contributor that must pass static analysis and approval gates. GitHub’s own approach with Copilot Agents frames them as orchestrated participants, not replacements. The goal isn’t to let the AI run wild; it’s to build guardrails so it can operate safely at scale. Every plan and action log becomes audit data. It’s a whole new layer of infrastructure to manage.
What To Do Now
So what’s the path forward? The article suggests starting with readiness, not hype. Pilot in tightly scoped areas like test generation or refactoring. Measure everything: defect rates, PR cycle time, change failure rate. And fundamentally, start viewing this as a data problem. Every context snapshot, test run, and code revision is structured data about engineering intent. The organizations that learn to index and reuse this “contextual memory” will build a durable advantage. The next 12-24 months will separate the winners from those who just bought a fancy model. The winners will be the ones who engineer their context and redesign their workflows. As the piece concludes, context + agent = leverage. Skip the first half, and the whole thing collapses.
