Topic

DevOps

All digests tagged DevOps

Multiplayer agentic engineering — Arjun Singh, Superconductor thumbnail

· 18:44

Multiplayer agentic engineering — Arjun Singh, Superconductor

The talk outlines 'multiplayer agentic engineering,' focusing on how human teams and AI agents can collaborate effectively across diverse systems. Key recommendations include making workflows model-agnostic, integrating agents into every human interface (Slack, GitHub), ensuring work visibility via artifacts, and treating all external signals (emails, meetings) as code inputs. Crucially, the speaker emphasizes that these advanced agentic workflows must operate within isolated cloud environments to enforce least privilege and prevent data exfiltration.

Key takeaways

  1. Model Agnosticism is Critical 5:01

    Do not rely on a single LLM or harness, as the best model changes frequently. Utilizing open-weight models (like GLM 5.2) allows teams to stay in control of costs and maintain workflow continuity.

  2. Agent Interfaces Must Be Universal 6:48

    Agents should not be trapped on a single laptop or platform (e.g., Slack). The agent session must maintain context when moving between relevant interfaces like Slack, the desktop app, and GitHub.

  3. External Signals Must Become Code 10:10

    Treat all external signals—customer calls, meetings (e.g., a Google Meet bot), bug reports from Sentry, or emails—as inputs that can automatically trigger and prioritize work for the coding agent.

  4. Work Must Be Visible Everywhere 9:09

    To improve collaboration, agents should make their work visible across all platforms using standardized artifacts (screenshots or videos), eliminating context switching.

  5. Use Isolated Cloud Environments 12:22

    Running agents in a cloud sandbox is essential for security, enabling non-technical staff to trigger real work without having development environments on their local machines. This enforces the principle of least privilege.

Watch on YouTube Full article

Always-on agents run production without the on-call tax — Justin Smith, Resolve AI thumbnail

· 24:56

Always-on agents run production without the on-call tax — Justin Smith, Resolve AI

The talk introduces the concept of 'always-on agents' designed to automate operational tasks in complex production environments, thereby reducing the burden of manual on-call work. While CI/CD handles baseline checks well, the biggest gap is monitoring non-alerted changes—such as feature flag rollouts or infrastructure updates—that require continuous context understanding. Background agents can run autonomously (on schedules, events, or messages) to perform deep analysis, root cause investigations, and proactive health checks across systems like Kafka pipelines.

Key takeaways

  1. The Operational Bottleneck 2:05

    A significant portion of an engineer's time (estimated at 70%) is spent running code in production—maintaining platforms, debugging incidents, and handling alerts—rather than writing it. This complexity increases with the velocity of change driven by AI.

  2. Background Agents vs. Incident Response 10:40

    While on-call agents handle immediate alerts and incidents, background agents address the 'long tail' of operational work—such as routine health checks, summarizing handoffs, or watching for subtle performance drifts (e.g., P99 drift) that don't trigger an alert.

  3. The Importance of Context 12:00

    Execution is easy; production context is hard. The value lies in building knowledge systems that can determine if a metric 'smells wrong' or understand the causal chain impact of a change, rather than just loading a dashboard.

Watch on YouTube Full article

Agents Write 95% of Our Code. Here's the Catch thumbnail

· 29:43

Agents Write 95% of Our Code. Here's the Catch

As AI agents assume control over an estimated 95% of code production in advanced software factories, traditional code review processes are insufficient. The talk introduces the role of the 'harness engineer,' a new skill set focused on system-level controls: defining invariants, performing deep analytics on agent logs and PR data, and implementing fine-grained risk/operations policies (like auto-merge ladders). This shift requires engineers to move from writing code features to building robust guardrails that ensure consistency and quality across agent-driven pipelines.

Key takeaways

  1. The Paradox of AI Adoption 25:24

    While AI coding tool adoption is high, benchmarks are becoming saturated. Concurrently, the number of reported bugs and incidents is rising, indicating that agents may generate code that lacks maintainability or systemic health (00:15:24).

  2. The Rise of the Harness Engineer 9:34

    Engineering focus must shift from pure feature building to defining and enforcing system invariants. The three critical new skill sets are Systems Thinking, Analytics, and Risk/Operations (00:09:34).

  3. Instruction Following Gap in Skills 8:23

    Tessl's internal skills benchmark revealed that while agents achieved high task completion rates, they only followed approximately 70% of the total instructions defined within a skill (00:08:22).

  4. Systemic Control through Invariants and CI Gates 12:56

    Engineers must identify general principles (invariants)—such as design system rules or desired code structure—and encode them into deterministic checks, verifiers, or CI gates to ensure consistency across the codebase (00:12:56).

Watch on YouTube Full article

The misaligned incentives behind AI coding agents thumbnail

· 50:16

The misaligned incentives behind AI coding agents

The conversation details how AI coding agents, exemplified by Devin, are fundamentally changing software engineering workflows. The industry is moving past simply training larger models and focusing intensely on optimizing cost-efficiency (token spend) and speed. Key technical advancements include the 'sidekick' agent architecture for achieving high price performance, developing advanced evaluation metrics like 'mergeability' via Frontier Code, and implementing proactive automation to shift human engineers into decision-making roles rather than routine coding tasks.

Key takeaways

  1. The Shift from Capability to Efficiency 8:36

    As agents mature, the bottleneck is shifting from model training size to running evaluations and managing costs. The focus has moved toward optimizing speed and cost rather than chasing the absolute best-performing frontier model for every task (5:56).

  2. The Role of Mergeability in Evaluation 14:01

    A critical gap in current evaluation benchmarks is 'mergeability'—determining if code, while technically correct, would improve the overall quality or maintainability of a codebase. Cognition developed Frontier Code to address this (8:41).

  3. Cost Optimization via Sidekick Architecture 35:46

    The 'sidekick' agent architecture allows for running both a high-quality, expensive model and a more price-performant model in parallel. This dual approach enables significant cost savings (up to 35% better price performance) without sacrificing quality (21:46).

  4. Proactive Automation and Productivity Guarantees

    Agents are moving from reactive task completion to proactive automation, handling tasks like triaging messages or suggesting fixes. This capability led Cognition to underwrite a $10 million productivity guarantee based on measuring 'productive engineering output' (46:51).

Watch on YouTube Full article

We Scored Oracle's Database Skill Live: 95% Isn't Enough thumbnail

· 14:35

We Scored Oracle's Database Skill Live: 95% Isn't Enough

The video demonstrates how Oracle's database team utilized AI 'skills'—encapsulated in a repository like `oracle/skills`—to guide AI agents in writing secure and best-practice compliant SQL. The process involved running an automated review (using Tessl) on a skill designed to improve database code generation, which initially scored 95%. Through iterative refinement and applying changes via a 'run, review, fix' cycle, the skill was successfully upgraded to a 100% success rate, showcasing a robust mechanism for encoding complex domain knowledge into AI workflows.

Key takeaways

  1. Purpose of Database Skills 5:51

    The primary function of the skill is to help agents write better SQL and database code by making them knowledgeable about the database's capabilities (e.g., property graphs, vector data). It helps discover what the database can do, rather than relying solely on general agent knowledge.

  2. Skill Review Process 13:44

    The skill was subjected to an automated review comparing it against best practices. The process involves running a 'run, review, fix' cycle, which applies changes and re-runs the validation in an agile style approach.

  3. Achieving 100% Compliance 14:35

    After making specific developer-suggested changes (e.g., adding a recommended sequence task), the skill's review score reached 100%, demonstrating continuous improvement and validation of domain knowledge.

Watch on YouTube Full article

The Dirty Secret of Forward Deployed Engineering — Natalie Meurer, Sierra thumbnail

· 16:49

The Dirty Secret of Forward Deployed Engineering — Natalie Meurer, Sierra

Forward Deployed Engineering (FDE) is not a single discipline but an outcome-focused role that has evolved significantly from initial platform stability work (DevOps) to complex data integration and customer enablement. The core thesis is that as coding becomes cheap due to AI agents, the value of engineering shifts entirely to understanding the customer's problem, integrating disparate data sources, and being accountable for measurable business outcomes.

Key takeaways

  1. FDE is an outcome-based role, not a code-writing one. 0:12

    The durable part of FDE involves integrating data, understanding the customer context, and maintaining accountability to a specific result, rather than merely writing software code.

  2. FDE's evolution tracks platform maturity. 0:06

    Early FDE focused heavily on DevOps and ensuring platform stability (e.g., deploying on an EC2 instance). This evolved into data integration using concepts like the Ontology, leading to modern platforms like Foundry that focus on 'data to decision-making.'

  3. Pricing models reflect accountability. 0:13

    The shift from seat-based pricing (assuming a tool) toward usage or outcome-based pricing confirms that the value lies in guaranteeing results, which is the hallmark of FDE.

  4. AI agents are simply FDE reborn. 0:15

    Agent engineering is viewed as a subset and manifestation of FDE principles, where engineers use LLMs to enable outcomes for customers. The role requires combining product knowledge with customer-facing solutioning.

Watch on YouTube Full article

Oleg Šelajev - You're absolutely right, it was your home directory! - AI Native DevCon June 2026 thumbnail

· 33:15

Oleg Šelajev - You're absolutely right, it was your home directory! - AI Native DevCon June 2026

The session addresses the security risks posed by autonomous AI agents running locally, noting that these agents can pose significant threats by accessing sensitive data and executing arbitrary code. To mitigate this risk, Docker introduces sandboxing using MicroVMs—a hardware-level isolation primitive superior to traditional containers. This approach allows developers to run powerful AI agents in a restricted environment with controlled access to the filesystem, network, and secrets, enabling high productivity without sacrificing security.

Key takeaways

  1. The Danger of Autonomous Agents 2:00

    AI agents are highly autonomous and persistent; if given sufficient access (data, external communication, internet), they can execute malicious actions like stealing SSH keys or cloud credentials, leading to massive security incidents. The stakes are asymmetric: the attacker only needs to succeed once.

  2. MicroVMs for Hard Isolation 6:00

    Traditional containers share a kernel and are insufficient for high-stakes AI agent sandboxing due to potential container escaping exploits. Docker's solution uses MicroVMs, providing hardware-level isolation that significantly raises the security boundary.

  3. The Role of Kits (YAML) 10:00

    To improve developer experience in isolated environments, 'Kits' are introduced. These declarative YAML files define reusable configurations for a sandbox, specifying required commands, tools (e.g., programming language toolchains), file placements, and network rules.

  4. Controlled Access Mechanisms 8:00

    Sandboxes implement critical controls including networking proxies (to block specific domains/services) and secrets injection mechanisms, allowing agents to function without direct access to the host machine's private data.

Watch on YouTube Full article

Why This Company Won't Let AI Agents Touch Bash thumbnail

· 1:06:04

Why This Company Won't Let AI Agents Touch Bash

The presentation details the evolution of an internal AI agent platform at Cyera, transforming a personal assistant project into an enterprise-wide tool for data security and operational efficiency. The core focus is on building robust guardrails to prevent agents from becoming uncontrolled 'black boxes.' Key architectural innovations include whitelisting tools over blacklisting them, implementing a structured citation system for verifiable claims, and replacing traditional RAG with a Knowledge Graph (KG) that allows agents to navigate interconnected data like an LLM wiki. The platform emphasizes controlled deployment, allowing multiple developers to build and own specialized agents while maintaining centralized security and governance.

Key takeaways

  1. Controlled Agent Architecture

    The system prioritizes control by whitelisting specific tools rather than blacklisting forbidden actions. A critical guardrail is the use of structured, validated output, ensuring that an agent cannot execute arbitrary code (like unrestricted Bash) or leak sensitive data outside its designated context.

  2. Citation and Hallucination Mitigation 20:55

    To ensure reliability, every claim generated by the agent must be backed by a citation. This is achieved by forcing the model to output structured blocks containing both the claim and the source reference. A second model then performs clean-context verification against the raw data to drastically reduce hallucinations.

  3. Knowledge Graph over RAG 32:33

    The platform utilizes a Knowledge Graph (KG) instead of standard RAG for context retrieval. This allows agents to 'walk' connections between entities (e.g., an exception, a service, and the related pull request), providing more structured and reliable data exploration than simply dumping retrieved documents.

  4. Adoption through Platform Engineering 50:27

    To drive adoption across engineering teams, the platform was designed to be easily customizable. By allowing users to name and modify their own agents (e.g., 'It's my agent'), the barrier to entry is lowered, promoting organic growth with a strategy of 'carrots, not sticks.'

Watch on YouTube Full article

6 Ways to Enhance Developer Productivity with AI thumbnail

· 12:53

6 Ways to Enhance Developer Productivity with AI

While AI is projected to write a significant portion of future code (e.g., 41% by 2026), achieving maximum developer productivity requires more than just adopting tools. Top-performing teams are restructuring their processes around AI's strengths—syntax and boilerplate—while protecting human focus for complex tasks like design, judgment, and learning. The six key areas for improvement involve automating repetitive work, prioritizing design over coding, fostering deep work (flow), minimizing context switching, investing in growth, and optimizing the entire toolchain.

Key takeaways

  1. AI's Role: Augmentation, Not Replacement 2:00

    The difference between average and top-tier teams is not the AI vendor used, but how they restructure their practices. AI excels at syntax, boilerplate, and well-defined transformations; humans must focus on design judgment and taste.

  2. Way One: Automate Smartly (CI/CD) 2:30

    Automation should target repetitive, error-prone tasks (e.g., automated testing, linters, security scanners). The goal is not to reduce work, but to free up cycles for higher-value engineering effort.

  3. Way Two: Design First, Experiment Later 3:25

    Before writing code, spend time on architectural sketches or flow charts. Using AI to brainstorm approaches and critique designs (finding edge cases) saves significant refactoring time.

  4. Way Three: Foster Flow State 4:30

    Productivity gains come from protecting deep work. Blocking calendars, minimizing notifications, and respecting 'heads down' time are critical for maintaining flow state.

  5. Way Four: Lessen Cognitive Load 5:40

    Mitigate context switching (the 'silent killer') by rotating on-call duties, enforcing targeted meeting agendas, and using AI coding assistants (e.g., GitHub Copilot) to enforce style guides automatically.

  6. Way Five: Make Room for Growth 7:10

    Treat code reviews as teaching opportunities rather than just gatekeeping. AI should compress the boring parts of growth, allowing human mentoring to focus on complex problem-solving.

  7. Way Six: Sharpen Tools of the Trade 8:40

    The toolchain (IDEs, frameworks, version control) must be modern and well-supported. Developer experience decisions should prioritize tools that 'get out of your way.'

Watch on YouTube Full article

Jack Wotherspoon - Humans vs. Slop: Rewriting the Rules of Open-Source - AI Native DevCon thumbnail

· 32:17

Jack Wotherspoon - Humans vs. Slop: Rewriting the Rules of Open-Source - AI Native DevCon

The rise of powerful AI agents is fundamentally changing open-source development by making code generation nearly free and abundant, leading to a flood of low-quality contributions ('AI slop'). This shift threatens the traditional human-to-human social contract of open source. Maintainers must implement new governance models—such as requiring issues before pull requests (PRs), rate limiting external contributors, and utilizing automation—to manage the influx of code while preserving quality and accountability.

Key takeaways

  1. The Open Source Shift 2:00

    Open-source development is moving from a human-to-human experience to one involving AI agents. The core challenge is that while generating code is cheap (sometimes free), reviewing, maintaining, and trusting the generated code remains expensive and difficult.

  2. Guardrails Against Slop 6:25

    To combat 'drive-by PRs' (where users submit fixes without prior discussion) and uncontrolled agent activity, maintainers should require contributors to file an Issue before submitting a Pull Request. This is cited as eliminating approximately 90% of drive-by PRs.

  3. Rate Limiting Contributions 7:00

    Implement rate limits on external contributors (e.g., limiting the number of active PRs) to prevent automated swarms of nonsensical code submissions, which can overwhelm maintainers.

  4. Trust and Governance Systems 9:40

    New systems are emerging to restore trust: 'Vouch' acts as a referral system for contributors, while 'Open Source Vacation' allows projects or solo maintainers to temporarily halt contributions when needed. Projects should also use context files (like `agents.md`) to guide all AI tools.

  5. Codifying Best Practices with Skills 11:20

    Implementing 'agent skills' (e.g., PR creator, docs writer) into the repository helps enforce best practices—such as running tests and following templates—for both human and AI contributors, thereby raising the overall quality bar.

Watch on YouTube Full article

Daniel Jones & Tomasz Maj - More software, faster - Odevo's AI Native transformation - AI DevCon '26 thumbnail

· 36:51

Daniel Jones & Tomasz Maj - More software, faster - Odevo's AI Native transformation - AI DevCon '26

Odevo details its AI-native transformation journey, moving from a highly heterogeneous tech landscape across multiple acquisitions and time zones. The core message is that adopting generative/agentic coding practices requires more than just providing licenses; it demands fundamental improvements in organizational processes, including robust CI/CD pipelines, standardized coding guidelines, and cultural shifts toward 'boldness' and experimentation. By systematizing training and focusing on failure modes, Odevo achieved significant metrics increases, such as 94% AI adoption among developers.

Key takeaways

  1. AI Adoption Requires Process Maturity 20:03

    Adopting agentic coding is not simple. Success hinges on foundational elements like having a reliable CI/CD platform, standardized coding practices, and comprehensive testing protocols. Without these fundamentals, generating code quickly will only expose bottlenecks elsewhere.

  2. The Importance of Discovery and Workshops 23:50

    Successful AI transformation requires a 'discovery' phase to understand the current state (the 'lay of the land') and using workshops (e.g., employing techniques like TRIZ) to address employee fears, reduce hesitancy, and build consensus on necessary improvements.

  3. Focus on Failure Modes 27:10

    Training should not focus only on the 'happy path.' It is crucial to teach developers about failure modes (e.g., context management, hallucination) and how agents operate in complex environments.

  4. The Biggest Impact is Boldness 32:10

    The most significant outcome of the AI transformation was not just increased efficiency but a cultural shift toward 'boldness'—the willingness to try ambitious, end-to-end agentic workflows and rewrite large systems quickly.

Watch on YouTube Full article

Peter Wilson & Davide Eynard - cq - Stack Overflow for Agents - AI Native DevCon June 2026 thumbnail

· 31:32

Peter Wilson & Davide Eynard - cq - Stack Overflow for Agents - AI Native DevCon June 2026

The session introduces CQ (Mozilla.ai's proposal), a system designed as a 'Stack Overflow for agents.' Its core purpose is to standardize and share knowledge units (KUs) across autonomous AI agents—locally, within an organization, or publicly. This prevents agents from repeating mistakes, wasting tokens, and ensures that lessons learned by one agent can benefit all others, thereby improving the reliability of complex automated workflows.

Key takeaways

  1. Knowledge Unit (KU) Standardization 17:09

    A KU is a standardized knowledge artifact (stored in JSON format) capturing solutions to novel problems. It includes domains, insights, actions taken, summaries, and metadata (languages/frameworks).

  2. Agentic Context Management 6:15

    Effective agent performance relies heavily on context injection. The system aims to move beyond simple memory files by allowing agents to query a centralized knowledge base for relevant solutions before starting a task.

  3. Layered Sharing Model 20:40

    CQ supports three levels of knowledge sharing: local (SQLite database, no review), private/team (requires user authentication and human-in-the-loop review), and public commons (CQ Exchange).

Watch on YouTube Full article

The DevOps Godfather on AI's "Dark Factory" Problem thumbnail

· 22:25

The DevOps Godfather on AI's "Dark Factory" Problem

Patrick Debois argues that the industry is approaching a 'dark factory' model of autonomous coding agents, mirroring historical skepticism around Continuous Delivery [0:02:51]. He emphasizes that success hinges not on better prompts or larger models, but on fundamentally restructuring teams and platforms. The developer role shifts from solo coder to agent orchestrator, requiring improvements in system-level engineering practices (e.g., building tooling for the agents) rather than just fixing the code produced by the agent [0:09:49]. Scaling this requires platform teams to centralize reusable components like skill registries and guardrails, moving organizations from a 'solo developer' model to a 'multiplayer system' [0:10:53].

Key takeaways

  1. Shift from Coder to Orchestrator 5:21

    The modern developer role evolves into that of an agent conductor or orchestrator, managing and guiding autonomous agents rather than writing all the code themselves. This requires a focus on system improvement over individual code fixes [0:02:51].

  2. Focus on Systemic Improvement 9:49

    The key mentality shift is to stop fixing the agent's output code and instead improve the underlying system, context, and tooling (harnesses/loops) that guide the agents [0:09:49].

  3. Platform Team Centralization 20:53

    To scale autonomous development, platform teams must own centralized components—such as skill registries, guardrails, and reusable harnesses—to prevent organizational sprawl and ensure consistency across teams [0:10:53].

  4. New Productivity Metrics

    Instead of measuring token spend, focus on two metrics: the number of human touches required for the agent to succeed, and the multiplier effect gained when a single system improvement benefits all users/teams [0:14:50].

Watch on YouTube Full article