AI Engineer Europe 2026
Stop babysitting your agents: building a context engine for mergeable code
Loading slides…
Read the talk
Stop babysitting your agents: context for mergeable code
A coding agent can pass its checks and still miss how your company works. Brandon Waselnuk shows how organizational context can guide research, implementation and review.
From a talk by Brandon Waselnuk
Before you start: Familiarity with coding agents, pull requests and MCP as a way to connect agents to tools will help you follow the examples.
A brilliant engineer on their first day
Type claude in a terminal and a capable software engineer appears—one that knows nothing about your organization. It does not know which services already exist, which architectural decisions still apply, or why the team rejected the obvious implementation last month. Supplying that knowledge becomes your job. This is the babysitting problem Brandon Waselnuk of Unblocked wants to remove.
His approach comes from building a context engine: a system that gathers and interprets organizational knowledge for agents. Alongside three failed assumptions and three implementation lessons, he introduces a workshop repository intended to provide one reusable component of that engine. It is a component, not a complete replacement for the system.
Before agents, engineers performed this work for themselves. On your first day, you might have strong technical skills but little local knowledge. Team interactions, rejected PRs and practical experience gradually teach you what works here. Becoming effective means learning to ask good questions, gather accurate context and discard information that does not help. With agents, the human often still performs that filtering, then translates the result into instructions for another worker.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From curated files to runtime research
The adoption ladder Waselnuk attributes to Basim Eldes starts with autocomplete and agentic IDEs, where a human initiates and guides the work. A next step is curated context: CLAUDE.md, AGENTS.md and repositories of corporate knowledge that agents can read. These files make useful instructions reusable, but someone must maintain them. They also leave out information engineers need from live systems.
A context engine extends that curated layer. When an engineer asks how to implement a feature, it retrieves information across SaaS applications and systems of record, incorporates runtime signals, and reasons across those sources. Its job is to investigate broadly enough to find the important constraints, then return a small response containing what the agent needs for its next decisions.
For a new integration, that response might explain the organization's factory pattern and other implementation conventions before the coding agent begins exploring. The agent can then send background workers to inspect relevant parts of the repository instead of asking them to discover the architecture from scratch. Waselnuk expects that ordering to improve accuracy, reduce token use and shorten the work. He frames the gap, with an attribution to Karpathy, as missing context rather than missing intelligence.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Why access does not establish understanding
Connecting an agent to organizational systems through MCP gives it access, but does not tell it where to look or what it does not know. A new engineer can build an entire service only to learn during review that the company already has one. An agent can make the same mistake even when the relevant information is technically reachable.
Waselnuk introduces a comparison using the same real prompt in two runs: one with Unblocked's context engine, the other with MCP access to every SaaS tool needed for the task. He reports that the latter output compiled and passed code checks, yet a senior engineer judged the implementation wrong and potentially system-breaking. Code that passes checks can still violate the system's design.
The first failed assumption is that naive retrieval-augmented generation over documents supplies sufficient context. Waselnuk explains the failure through a radiology analogy, satisfaction of search: after finding one abnormality that appears to explain a patient's symptoms, the searcher stops looking and may miss another problem. For an agent asked to create a Zendesk integration, the equivalent is retrieving one plausible implementation pattern and treating it as the answer.
Stopping early leaves the agent without the evidence needed to identify the best implementation. The engineer then reads the result, rejects it and points the agent toward another file. That correction loop restores the human as the context engine. Adding more MCP connections does not fix the stopping rule: connectors provide paths to information, not the reasoning that determines whether the investigation is complete.
The third assumption is that a sufficiently large context window will solve the problem. Waselnuk describes the disappointment of filling a million-token window and expecting the agent to reason effectively over everything inside it. His objection is that volume alone does not supply useful entities and relationships. He extends that argument to a hypothetical hundred-million-token window, distinguishing finding a particular item from understanding how the organization works. This is his architectural argument, not a measured context-window limit.
These approaches leave a familiar gap: the agent can see whether code compiles, while important architectural constraints remain undiscovered. It can spend a long session grepping for factory patterns, but the discovery costs tokens and the session's accumulated understanding may disappear when the terminal closes. The next task then pays for the same investigation again.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Use relationships to find and interpret evidence
A context engine needs to understand who is asking. For the Zendesk request, the useful starting points include the engineer's repositories, PR history and collaborators. A social graph provides those connections, allowing the engine to narrow the meaning of a request before searching. Waselnuk reports customers with twenty thousand members, where an identical request can refer to very different work depending on the person asking it.
Relationships also help interpret contradictory evidence. Suppose code on main implements one behavior, but a Slack conversation contains the CTO's statement that the implementation is wrong. Treating the code as the sole source of truth would conceal the intended correction. Treating the message as a replacement for the code would conceal what actually runs.
The engine should return the source code together with the correction and its attribution. The CTO's role is an authority signal that helps explain why the disagreement matters; it is not proof that a message is infallible. Waselnuk describes this as reasoning about truth across sources, and explicitly says the problem is not fully solved.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Deliver useful context without widening access
Permission enforcement belongs inside this retrieval process. Waselnuk describes carrying the OAuth identity model through MCP so that the requesting user's access governs what the engine returns. Ingesting Slack or Microsoft Teams conversations must not make everyone's private conversations available to everyone else: his example allows answers from a user's own private chats while excluding chats they cannot access.
That is a design requirement, not something an MCP connection establishes automatically. Current Data Shield documentation describes permission enforcement configured per source: Slack enforcement is always enabled, other supported sources require configuration, and some sources do not support it. The requesting identity and each source's enforcement settings therefore matter to the promised boundary.
The engine ingests organizational sources and serves multiple interfaces. Human engineers can ask questions in Slack; coding agents can request the same kind of guidance through a tool. Background and cloud agents especially need questions answered by a machine, otherwise an overnight run may produce a request for permission rather than a PR. That makes context delivery part of the agent's operating environment, not just an optional document attached to its first prompt.
Waselnuk groups the engine's requirements into six capabilities:
| Capability | Purpose |
|---|---|
| Unified system context | Reason across systems of record |
| Targeted retrieval | Find the information needed for this task |
| Conflict resolution | Interpret contradictory evidence |
| Data governance | Enforce the requester's access |
| Personalized relevance | Use identity and working relationships |
| Token optimization | Return concise, useful context |
Token optimization has two parts. The agent avoids repeatedly discovering the same organizational patterns, and the engine compresses its cross-source investigation into the information the agent actually needs. The small response is the result of the research, not a substitute for doing it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What changed in the reviewed code
Returning to the task comparison, Waselnuk says Claude generated the comparison, including its charts and numbers. The useful evidence in his account is the engineering behavior: both runs received the same prompt, but one had all the required direct MCP connections while the other had only the context engine.
| Review concern | Direct MCP access | Context-engine run |
|---|---|---|
| Existing fallback behavior | Missed the Bedrock fallback | No corresponding failure reported |
| Existing callers | Broke custom callers | No corresponding failure reported |
| Senior review | Implementation judged unmergeable | Accepted subject to a nitpick |
Waselnuk associates the first result with prototype-like agent work: mocks and locally plausible changes that fail to preserve how the surrounding system operates. The assisted PR, he reports, required only a small correction before the reviewer would accept it.
This remains a speaker-reported task comparison. A later Unblocked account identifies the change as adaptive thinking across three Kotlin SDK modules, but reports compilation failures where the talk describes an output that compiled. The vendor accounts also differ in their token wording. Those discrepancies prevent a clean numerical comparison; the concrete fallback and caller failures explain the lesson without treating the generated charts as a general benchmark.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Three assumptions that failed in the engine
Access would become understanding. Unblocked initially expected the model to handle interpretation once it could reach the data. Waselnuk says that expectation did not resolve the problem over years of development. Referencing contemporary cloud-agent launches and the morning's conference discussion, he argues that context must enter the agent harness deliberately.
Conflicts could stay hidden. Early versions allowed the agent to choose when sources disagreed. Hiding the disagreement removed information needed to judge the choice. The lesson was to surface and address conflicts, rather than letting a polished answer conceal incompatible evidence.
A good answer was safe to cache. Positive feedback made answer caching attractive as a latency optimization. But a correct answer describes a system at a particular point in time. If the system changes, returning yesterday's answer to today's identical question can be wrong. Waselnuk uses changes within twenty-four hours to illustrate that risk and recommends against this answer-caching approach, while acknowledging that some questions do have stable answers. Preserving reusable context and reusing a finished answer are different freshness problems.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Constructing and using an expert graph
The closing demonstration begins with the workshop's social-graph component. It was still closed source during the presentation, although workshop teams had used it to ship code. The corresponding Social Graph Builder repository was subsequently announced as open source in an April 17 post; the release promises made onstage should be read as plans at that time.
The tool constructs a graph of the engineering organization, with people represented as nodes and working relationships as edges. Waselnuk points to Rasheen's large node as an indication of how much he ships. Selecting a person exposes collaborators, whose code they review and the areas where they work. The graph is generated algorithmically, with labeling that uses an Anthropic API key.
The graph becomes useful when a query is underspecified. Identify Rasheen, follow his collaboration relationships, then narrow attention to the codebases he works in. A vague request to fix a bug now has a more useful search scope. Waselnuk presents finding the right bug as a likely benefit of that traversal, not as a demonstrated diagnosis in this example. The graph supplies evidence for where to investigate; the engine still has to reason through the request.
Pointing the tool at a repository constructs expertise information across libraries, services and other areas of the business. The demo also exposes a heat-map grid for authorship and review relationships, plus peer tables for inspecting whom someone such as Andre works with. These views make the relationships available for inspection as well as for use by the context engine.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Research first, then explore and plan
In the final demo, Waselnuk switches to Ghostty and asks how to build a new first-class Zendesk integration. He explicitly tells the agent to use Unblocked's MCP so the demo will take that path. The request can be expressed at the CLI without prescribing repository changes in advance:
bash
claude 'Use the Unblocked MCP to research how to add a new first-class Zendesk integration. Then inspect the relevant code and write an implementation plan.'
The important instruction is to research the organization's implementation before planning the change.
The agent selects the historical research_task tool, constructs a query from its MCP interface and requests high reasoning effort. The April 24 changelog records the later replacement of that tool with context_research; the recording shows the earlier interface. Once the research packet returns, the agent launches its explore agents. They now have guidance about where to look.
The resulting plan covers provider registration, the factory pattern, library modules and the client. The terminal's final planning view also shows proposed module changes and verification steps. Waselnuk considers the plan largely correct, but expects a couple more prompts to refine it. This is a planning result, not a demonstration of an implemented and verified Zendesk integration.
The MCP remains available while the agent executes. Waselnuk's recommended development sequence is therefore:
- Plan with context. Research the organization's patterns and constraints before deciding what to change.
- Execute with access to further research. Let the agent return to the engine as new questions arise.
- Review with context again. Use the engine to assess the change against organizational knowledge, alongside the code review itself.
The engine's role continues beyond the initial prompt: it supports the decisions that turn a plausible implementation into a change the team can accept.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
Further reading
Explains permission enforcement, identity setup and supported data sources for Unblocked answers.
Updates since the talk
Build collaboration graphs, team clusters and code expertise views from GitHub pull-request history.
Brandon Waselnuk introduces the open-source collaboration graph component and explains its role in organizational context.
Current documentation for research across code, pull requests, documents, issues and messaging, including citations and effort controls.
Full transcript
Loading transcript…