Production telemetry → context auto-update

At L3 and L4, operational context (deployment status, error rates, service health) is provided to agents at task start through MCP servers and BYOC pipelines. This works well when context is fetched once and the production state is stable. But production systems change constantly: a service that was healthy when the agent started a task may be degraded by the time the agent proposes a change. Static operational context, even if it was accurate at session start, becomes stale.

Production telemetry context auto-update closes this loop. Agent context is subscribed to production signals - not just fetched once at session start, but continuously updated as production state changes. When an error rate crosses a threshold, when a deployment is rolled back, when an alert fires, when a circuit breaker opens - the relevant agents receive updated context automatically, without a human relaying the information.

The architecture is event-driven: production monitoring systems (Datadog, Grafana, PagerDuty, etc.) emit events when significant state changes occur. A context update pipeline subscribes to these events, determines which agents and tasks are affected, and pushes updated operational context to those agents. The agent's operational understanding of the system stays synchronized with reality, not with a snapshot taken at session start.

At L5 (Autonomous), this capability becomes essential. When agents are autonomously making code changes, deploying those changes, and monitoring the result, the feedback loop between production behavior and agent context must be automatic. An agent that doesn't know a service is currently degraded might confidently generate changes that make the situation worse. An agent that receives a real-time alert about increased error rates in a related service will incorporate that information into its next decision.

The gap between agent context and production reality is a safety risk that grows with the autonomy level of the agent:

• Agents making unsafe changes - an agent that doesn't know a downstream service is operating at reduced capacity might generate a change that removes a safety check "to simplify the code"
• Missed integration with incident response - when production is degraded, agents working on related code should know about the degradation and adjust their suggestions accordingly
• Compounding errors in autonomous workflows - in multi-step agent workflows, a wrong assumption about production state in step 3 can lead to a cascade of wrong decisions in steps 4-10
• Faster incident response - when agents are automatically informed about production anomalies, they can proactively generate hypotheses and diagnostic steps without waiting for a human to relay the information
• Closed-loop validation - agents that have deployed a change and are monitoring its impact need real-time telemetry to evaluate whether the change was successful

The L5 vision is an agent that can observe the production environment, reason about what's happening, and act - all without requiring a human to bridge between production monitoring tools and the agent's context window.

1. Inventory your telemetry signals - Identify the production signals that are most relevant to development decisions: error rate anomalies, latency degradations, deployment events (deploys, rollbacks), circuit breaker state, and on-call alert firings. These are your candidate auto-update triggers.
2. Build a telemetry event bus - Route production events from your monitoring systems into a unified event stream. Webhooks from Datadog, Grafana alerts, PagerDuty incidents, and CI/CD deployment events can be unified through a message broker (Kafka, SQS, or a simple webhook aggregator).
3. Define the context impact model - For each event type, define which agent contexts it affects. A degradation alert for payments-service affects any agent working in repositories that depend on that service. The impact model requires the service dependency graph (from your knowledge graph infrastructure).
4. Build the context update pipeline - When an event fires, the pipeline queries the impact model to identify affected agents/sessions, assembles an updated operational context snippet, and pushes it to the affected agents through the agent orchestration layer.
5. Implement agent response protocols - Define how agents should behave when they receive a context update mid-task. Options: pause and re-evaluate the current plan, add a warning to the generated output, flag the task for human review. Different event severities should trigger different protocols.
6. Start with passive observation - In the first phase, agents receive telemetry updates and include relevant signals in their output (e.g., "Note: the payment service has elevated error rates - the change I'm proposing does not affect the payment path"). Automated actions come later, after the passive phase validates the context model.

Alert fatigue in agent context. If every minor production fluctuation triggers a context update, agents will receive a constant stream of signals that crowd out more important context. Implement alerting thresholds appropriate for agent context updates - these should be higher than human notification thresholds, since agents need to distinguish significant events from noise.

Not handling conflicting context updates. An agent may receive a "service restored" update moments after receiving a "service degraded" update, or a "deployment started" update before receiving the "deployment succeeded" confirmation. The context update pipeline must handle event ordering and implement eventual consistency - not "last write wins" without order awareness.

Giving agents production write access too early. The natural evolution is: agents observe production telemetry → agents reason about production state → agents take production actions. The transition from step 2 to step 3 requires extensive validation. Start with read-only telemetry. Earn trust through correct passive observation before introducing production actions.

Not testing the context update pipeline as infrastructure. Production telemetry auto-update is infrastructure that agents depend on for safety. If the pipeline fails silently (events are lost, updates are delayed), agents operate on stale context without knowing it. Implement the pipeline with the same reliability standards as any other safety-critical infrastructure: monitoring, alerting, SLA targets, and runbooks.