AI Engineer World's Fair 2026
Your AI Agent Has No Nervous System — Matt Gibiec, Dynatrace
Loading slides…
Read the talk
Your AI Agent Has No Nervous System
Matt Gibiec introduces Bluebox by Dynatrace as a way to give coding agents production context: service dependencies, historical behavior and repository changes that inform testing, diagnosis and fixes, with a human deciding what ships.
From a talk by Matt Gibiec
At a glance
Ideas worth remembering
A coding agent needs context about service dependencies and application usage to judge changes beyond the code immediately in front of it.
Bluebox proposes bringing production dependency information into local testing so developers can consider connected workloads before merging a feature.
Historical behavior identifies deviations; repository history adds changes to investigate. Together they can guide diagnosis and system-aware repair.
Plan the intended user outcome before prompting the agent, and preserve a human decision over whether the resulting feature or fix ships.
Fast agents still leave engineering questions unanswered
A coding agent can keep repeating the same unsuccessful action, consuming tokens without producing the result you need. Matt Gibiec, Regional Director of Solutions Engineering for AI Native at Dynatrace, opens with that familiar frustration. His “nervous system” metaphor asks what information an agent needs to reason usefully about the work people are handing it.
The questions change with the engineering role:
- Developers: Why does Claude keep trying the same thing when it is not working?
- Team leads: How will the team handle operational issues and security concerns once agents are running?
- Engineering leadership: Does the application or agent deliver value to users, and how will the organization measure that value?
“Let's just get things deployed” postpones the last two questions until after the engineering time and money have been spent. Gibiec calls for a pause to define what the agent should accomplish and how success will be measured. He raises the measurement problem rather than supplying a particular metric: shipping an agent is an activity; whether it helps users remains a question the team must answer.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What the agent needs to see
Agents “operate at speed,” but their decisions depend on the information they can reach. Missing details, missing environmental context and missing permissions to retrieve tool data can all leave an agent reasoning from an incomplete picture. Faster execution then accelerates decisions whose premises may be wrong.
For a coding agent working through the software development lifecycle, that picture includes how services depend on one another and how users actually use the application. A change can look sensible when viewed as an isolated piece of code while being unsuitable for the system that runs it. “Context is king” is the short version of the argument: the metaphorical nervous system is information connecting an action to its environment.
Bluebox by Dynatrace is introduced as an agent that supplies this context to coding agents and proprietary agents during development. The following scenarios describe its intended preview capabilities, rather than a demonstrated implementation or measured guarantee that it prevents failures. Its proposed role is to bring knowledge of the running system into the places where developers and agents make changes.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A local success can break three other services
The central example starts with a developer building a feature or an agent skill. Local testing passes. The developer merges it into the main branch and pushes it out; suddenly, three other services are broken. This is a hypothetical scenario in the talk, but its observable change is concrete: the feature works in isolation, then disrupts a process when it joins other applications and agents.
The proposed intervention happens before that merge. Bluebox would provide service and dependency mappings for agents and AI workloads, bringing production context into local testing. That changes the question the developer can ask: beyond whether the new feature performs its own task, what else connects to this workload and could be affected by the change?
The important distinction is between testing a feature and understanding its effects across the system. Dependency context helps identify the connected work that deserves attention during testing. The talk describes bringing information from production into development; it does not describe recreating the entire production environment locally.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Connect a runtime deviation to a repository change
The next scenario follows what happens once workloads are running. The goal is to find trouble before it affects users. Bluebox's proposed detection mechanism combines two kinds of information:
- Historical behavior: Environment data and historical loads establish what normal behavior looks like. A service slowing down or producing new errors becomes a deviation worth investigating.
- Repository changes: Integration with the code repository adds information about what changed in the application or workload. That history can be overlaid on the runtime deviation to investigate a recent push or merge.
Return to the feature that passed locally and then disrupted connected services. Runtime history supplies the before-and-after signal: a service is now slower, or it now throws errors it did not throw before. Repository history supplies a candidate explanation: a change was pushed around the incident. Bluebox would bring that combined context to the developer's agent in the IDE. The intended result is a shorter path from noticing the symptom to investigating the relevant change; an overlap in timing alone does not establish causation, and the talk does not specify the causal analysis.
What information must meet before an IDE notification becomes useful? The diagram shows runtime behavior and repository history entering the same investigation. Historical data explains why the behavior is unusual; change history helps narrow where to look. Neither input performs the other's job.
Runtime symptoms meet change history
Read the diagram as text
- Historical environment data. Past behavior and loads establish what normal looks like.
- Runtime deviation. A service slows down or starts producing new errors.
- Repository change history. Identify changes pushed to the application or workload.
- Combined investigation context. Overlay the issue with changes that may explain it.
- Developer's agent in the IDE. Receive the service issue and relevant context.
- Historical environment data → Runtime deviation: Compare with normal behavior.
- Runtime deviation → Combined investigation context: Observed symptom.
- Repository change history → Combined investigation context: Changes to investigate.
- Combined investigation context → Developer's agent in the IDE: Inform the developer and agent.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A one-line fix still has system-wide consequences
Detection leads to remediation. With repository context, Bluebox would know what changed and who pushed it, then provide developers with suggested steps for fixing the affected service, agent or workload. This extends the earlier flow: environmental context supports testing, runtime data reveals an issue, and repository information guides the response.
The tempting shortcut is a one-line change that removes the immediate error. But that line participates in the same network of dependencies that made the original local test incomplete. For the feature that disrupted three services, a proposed repair therefore needs two checks: does it address the current problem, and what will it do to the rest of the application? The dependency map matters again because fixing one workload can change behavior elsewhere.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Brief the agent before building starts
The next use of context moves earlier than testing. Someone proposes a feature, and developers immediately start building it. The missing step is research into what the feature should deliver to users and what the team is trying to accomplish. Gibiec's instruction is compact: “plan before you prompt.”
Bluebox would bring context from the existing application and agents into planning for the next feature or release. Service dependencies help explain where a change will operate; knowledge of application usage helps inform what it needs to accomplish. This returns to the opening question about value: the agent needs a useful brief before it can efficiently implement one. Environmental data informs that brief, while the team still has to decide the desired user outcome.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Observe, suggest a fix, then let a human decide
More context enables more automation, which makes control over changes more important. The closing workflow starts with observing the environment and building dependency mappings. That context reaches developers during local testing. When an issue appears, the system suggests a fix using knowledge of the monitored application and agents, then leaves the decision to push the feature or repair with a human.
Where does automation stop and human control begin? The diagram places the decision after observation, detection and the proposed fix. This arrangement gives the agent more evidence and gives the developer a recommendation, while preserving the developer's ability to withhold the change. Better context supports a decision; it does not make that decision disappear.
The closing aim is to “help agents ship code you trust to production.” At the time of the recording, Gibiec invited attendees to sign up for a Bluebox preview, with access to follow through outreach. The practical proposal ends with the same division of work: observation supplies the facts, agents help prepare the change, and a person decides whether it should ship.
Context informs the fix; a human controls the push
Read the diagram as text
- Observe the environment. Build application context and dependency mappings.
- Inform local testing. Provide production details to developers.
- Detect an issue. Use monitored behavior to identify trouble.
- Suggest a contextual fix. Account for the affected application, agents and dependencies.
- Human shipping decision. Decide whether to push the feature or fix.
- Observe the environment → Inform local testing: Production context.
- Observe the environment → Detect an issue: Monitoring context.
- Detect an issue → Suggest a contextual fix: Issue to address.
- Observe the environment → Suggest a contextual fix: System dependencies.
- Suggest a contextual fix → Human shipping decision: Proposed change.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
Related talks
- Beating RL With Reflection: GEPA and Optimize Anything
Explains how execution traces, tool responses and errors can guide changes to prompts and agent programs—a complementary mechanism for turning environmental feedback into better behavior.
Full transcript
Loading transcript…