MLOps Community

The core thesis is that improving an agent's ability to write and execute code makes it better at everything else. This 'positive transfer' capability means agents with coding skills are effectively AGI-complete, as they can write their own tools and interact with various systems.

Code provides an ideal training ground because its output (e.g., a function, schema) can be programmatically verified (linted or passed through unit tests). This verifiable feedback loop allows agents to learn and refine their performance iteratively, which is crucial for autonomous workflows.

The most successful platforms will be those that achieve convergence—integrating context, surfaces, and unit economics into a single system (a 'System of Record'). Fragmentation (e.g., Slack's data walls) is identified as the primary enemy to agentic workflow adoption.

The trend suggests that much of today's office work will be handled by agents. This shift means platforms must evolve from being communication hubs (like Slack) to becoming the central operational layer where all data and tasks reside.

AI agents' primary value is shifting from simply reducing MTTR to building an agent that learns from every investigation. The goal is creating a compounding operational memory, allowing the system to improve its decision-making process and predict failure modes rather than just reacting to alerts.

The 'harness' is defined as everything between the user and the LLM—including prompts, skills, file systems, and tools. The challenge is balancing necessary guardrails (to prevent agents from doing wrong things) with enough freedom to allow for complex, non-deterministic problem solving.

Because every company's infrastructure (e.g., Gojek vs. Uber) is unique, agents cannot simply be trained on general knowledge. Durable development requires simulating and testing agent performance across diverse, idiosyncratic production environments.

The next frontier involves multi-agent systems (e.g., a Coding Agent working with an SRE Agent). These teams require defined governance structures, similar to a RACI matrix, ensuring agents know their roles and how to share context without losing isolation.

Meta-harnesses, such as Omnigent, sit above individual models (e.g., Claude Code, Codex, Pi) and harnesses, allowing developers to compose different components without rebuilding the entire context or workflow.

Advanced agent techniques include having agents debate each other to surface unknown questions, and 'forking' conversations to explore parallel threads while maintaining shared original context.

AI spend is repeating the CapEx-to-OpEx shift. Governance must be pushed down to developers (giving them visibility into token usage) while retaining central policies for cost control and approval.

Agents require cheap, stateful memory. This has led to a resurgence in the use of traditional databases like Postgres, Lakebase, and serverless options for persistent context.

The traditional 'three pillars' (metrics, logs, traces) are considered overkill for modern agentic workflows. By focusing solely on logs, instrumentation becomes significantly simpler, requiring only basic logging statements, as the platform can reconstruct metrics and traces from log data.

Instead of using AI to triage noisy alerts (alert fatigue), Sazabi autonomously generates actionable alerts directly from logs and codebase analysis. The agent determines what is meaningful to the user at runtime.

Sazabi maintains persistent, shared memory across multiple parallel sub-agents and threads by committing findings (e.g., issue lists, facts) to a dedicated Git branch within the sandbox environment. This allows agents to benefit from collective findings.

The platform operates in a read-only system with no public internet access, ensuring security. All actions are routed through an isolated sandbox environment (e.g., using `bash` tools) to prevent data exfiltration or unauthorized changes.

Agents must be classified based on the potential blast radius: 1) Reversible work (e.g., ticket enrichment); 2) Sensitive work (affecting system stability, requiring tighter controls); and 3) Consequential work (touching legal or customer policy documents, highest risk).

Before deployment, four non-negotiable controls must be in place: Agent Identity (credentials treated as first-class data with strict expiration/authorization); Input Controls (guardrails against prompt injection and ensuring tool allow-listing); Output Controls (limiting tool calls, retries, and preventing toxic output); and Auditability.

Auditing must go beyond simple logging. A comprehensive framework requires monitoring Quality (using LLM-as-judge), Performance (focusing on P99 latency), Safety (PII redaction/filters), Cost (tracking expenditure at the run level), and Business Impact (logging the agent's chain of thought decision process).

Engineers must maintain ownership over the system architecture, even if AI generates the code. The core logic and blueprints must be human-owned to ensure accountability and proper review processes.