The Operational Bottleneck

Modern software development has seen a massive increase in shipping velocity, but this has created a hidden crisis: engineers spend roughly 70% of their time on operational maintenance—debugging, scaling, managing incidents, and updating runbooks—rather than writing new features. This "on-call tax" is exacerbated by the complexity of AI-integrated systems, which often lack the structured observability required to handle the volume of changes and potential failures.

The Role of Background Agents

To combat this, Resolve AI advocates for moving beyond simple coding agents toward "background agents" that operate autonomously in production. Unlike reactive monitoring tools, these agents possess both an execution engine (the ability to interact with tools) and production context (the ability to understand if a metric is not just anomalous, but actually problematic).

These agents function by:

  • Operating on triggers: They can be scheduled (e.g., morning reports), event-driven (e.g., CI/CD pipeline updates), or message-based (e.g., Slack queries).
  • Maintaining state: They run in sandboxed cloud environments with persistent file systems, allowing them to self-organize and learn from previous tasks.
  • Learning loops: By reflecting on past investigations, the agents improve their reasoning and accuracy over time, effectively building a memory of how specific services interact and where hotspots reside.

Practical Use Cases

  • Deployment Monitoring: Instead of relying on static CI/CD checks, agents dynamically analyze changes, identify relevant telemetry, and monitor the health of specific services or causal chains (like Kafka pipelines) over extended periods.
  • Operational Reports & Handoffs: Agents automate the "ceremonial" work of summarizing incident trends and system health, ensuring the next on-call engineer has a clear picture of the state of the system.
  • First-Responder Support: By monitoring Slack channels, agents can answer routine engineering questions using internal knowledge bases. If the agent lacks confidence, it can DM a human for confirmation before responding, reducing context-switching for the team.

Key Takeaways

  • Shift focus from code to operations: Recognize that the primary bottleneck in modern engineering is not writing code, but running it.
  • Context is king: An execution engine without production context is dangerous. Ensure your agents have the ability to interpret whether a system state is "normal" or "wrong."
  • Integrate where you live: Surface agent activity in communication platforms like Slack or MS Teams to minimize friction and cognitive load.
  • Automate the long tail: Use agents for the repetitive, non-alerting tasks—like checking P99 drift or capacity reporting—that don't trigger formal incidents but consume significant engineering time.
  • Build memory into your agents: Ensure your agent architecture includes a learning loop so that it improves its understanding of your specific system architecture over time.

Notable Quotes

  • "70% of the time from an engineer is actually not just focused on writing code; it's actually spent on actually running the code that is actually shipped into production."
  • "It's one thing to go check a dashboard; it's another thing to say that metric smells off... the production context is going to say this feels wrong and I don't know if I can even explain why it feels wrong."
  • "Our goal is not to sit here and say we're going to replace an entire CI/CD pipeline... but this can sort of patch a lot of parts of your system that may not be as robust as they should be."