# The Missing Primitive for Agent Swarms

Lou Bichard

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/5Sui_OnSRlY-missing-primitive-agent-swarms) · [Video](https://www.youtube.com/watch?v=5Sui_OnSRlY)

## The Missing Primitive for Agent Swarms

Running more coding agents is only the beginning. A software factory also needs a way to preserve context, enforce development steps, and decide when work may advance.

Familiarity with coding agents, pull requests, CI, and the distinction between containers and virtual machines will help.

### Who is still driving the work?

[0:21](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=21s)

What would it take for coding agents to carry work from development into production without a person driving every change? That is the infrastructure question behind Lou Bichard’s exploration of subagents and swarms. Bichard introduces himself as Ona’s field CTO, with a background in principal engineering, platform engineering, and product management.

The ambition is a **software factory**: incrementally remove the human from actively operating each part of the software development life cycle, or SDLC. Bichard initially describes this as something everyone is trying to build, then qualifies that impression: many people he has met are not yet thinking in those terms. His definition is also narrower than one engineer operating many coding agents simultaneously. That engineer still drives the work. In a software factory, work would increasingly flow through development and into production automatically. This remains an early ambition, not a description of routine industry practice.

![Slide titled “Everyone is trying to build a software factory,” with a definition above illustrated arms along Plan, Code, Review, Test, and Deploy.](https://ai.engineer/api/talk-essay-media/1934f1bc7fcbaad3296c3b7db8734f908be80c9efef4e0a1217da71931def885)

The software-factory vision spans planning, coding, review, testing, and deployment.

### Swarms, fleets, and the events that start them

[1:50](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=110s)

Bichard’s Background Agents website collects visualizations of several ways to organize coding agents. These patterns answer different questions: how to divide one task, how to distribute a change across an organization, and when to start work.

| Pattern | Organization of work | Example |
|---|---|---|
| **Swarm** | One intent fans out, then converges | Several agents contribute to one PR or task |
| **Fleet** | Agents fan out across repositories | An organization-wide maintenance change |
| **Events** | An external signal activates agents | A PR is raised or a Linear ticket is created |

A swarm resembles the familiar parent-and-subagent pattern. A fleet broadens the scope across repositories; Bichard describes it as an existing Ona capability. Events supply the activation mechanism that a software factory needs once a human is no longer starting every task. Much of that mechanism already exists as webhook infrastructure.

### Simple changes become organizational workloads

[3:11](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=191s)

Published internal systems make this infrastructure more concrete. Bichard describes [Stripe’s Minions](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents) as coding agents plugged into Stripe’s existing infrastructure. Bichard reports that Minions drives thousands of pull requests inside Stripe, without specifying a time interval. He also points to Ramp’s Inspect as another internal system for running background agents. These are examples of organizations building execution infrastructure around agents, rather than treating an agent as an isolated chat session.

Ona approaches the problem through development environments. Bichard describes roughly six years of environment infrastructure, with deeper agent integration during the preceding year or two. Its fleet feature uses schedules or triggers to launch agents across repositories for work such as CVE remediation, increasing test coverage, or enforcing a common change.

The individual task may be relatively simple for current LLMs. The difficulty is applying it across thousands of teams or repositories. In the workflow interface, prompts and scripts become the ingredients for distributing that work across an organization. The scale problem therefore includes both execution and the organizational boundaries through which the change must pass.

### Turn agent failures into repository feedback

[4:49](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=289s)

Running an agent repeatedly only helps if the system retains what those runs teach you. Bichard points to OpenAI’s [harness engineering article](https://openai.com/index/harness-engineering/), by Ryan Lopopolo, as an expression of this approach: encode development process in the repository, including context files and `AGENTS.md`.

He treats **harness engineering** as an extension of context engineering. Skills, instructions, unit tests, and other repository artifacts all contribute either guidance or feedback. The practical loop is:

1. Let the agent attempt the work.
2. Find the point where it loses its way.
3. Encode the missing knowledge or feedback in the repository or context.
4. Let later runs use that feedback to proceed further through the development process.

The repository becomes part of the agent’s operating environment, not merely the code it edits.

### Execution infrastructure is only part of the system

[5:40](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=340s)

At the infrastructure level, the factory needs four distinct capabilities:

- **Runtime:** somewhere for an agent to execute.
- **Orchestration:** a way to scale agents horizontally up and down.
- **Triggers:** a way to start work when an event occurs.
- **Coordination:** a way for agents to interact, pick up tasks from one another, and collaborate.

Bichard considers the runtime largely solved. The harder question is what happens between running agents: how they exchange responsibility and move shared work forward.

Execution can use separate threads, Git worktrees, containers, VMs, or microVMs. Ona describes its runtime units as development environments. Bichard argues for VM isolation for substantial development tasks on two grounds: security and resource contention. Containers are not, in his account, a sufficient security boundary for this use case; bursty workloads in Kubernetes pods can also compete for compute and create noisy neighbors. These are Ona’s reasons for choosing VMs, rather than guarantees that a VM alone resolves every security or capacity concern.

### One implementation task, two kinds of subagent

[7:17](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=437s)

The Ona demonstration uses a recording made in Bichard’s hotel room the previous day, avoiding dependence on venue Wi-Fi. The interface’s left sidebar contains two tasks. The implementation exercise uses [OpenAI Symphony](https://github.com/openai/symphony), whose detailed [repository specification](https://github.com/openai/symphony/blob/main/SPEC.md) gives the agent a substantial description of what to build.

The first task asks for **process-based subagents**: one VM contains the parent agent and the child processes it starts. The second asks the agent to create a fleet of separate VMs through the platform. In the latter arrangement, adding a worker also means provisioning another environment. Bichard describes the potential scale as bounded by spending and cloud-provider capacity.

In the VM variant, the parent spawns three subagents in separate VMs. Each child receives a limited piece of context and an individual task, then passes messages back to the controlling parent. The parent remains responsible for governing the overall implementation. This immediately creates an interface problem: as the task tree grows, users need a way to inspect and control the workers without losing the overall task.

![Dark Ona interface with agent entries in the left sidebar, a central checklist and three-row environment table, and a changes panel on the right.](https://ai.engineer/api/talk-essay-media/4b4d806a3c9e130446e2700d790687827a43079b29ae4f555c23d93d58a388dc)

Ona shows the parent agent’s task checklist and three subagents in separate environments.

As agents come online, their environments start and their task progress becomes visible. Both demo tasks display seven sub-items, a count Bichard notes without explaining. He describes the intended end of the lifecycle as terminating the VMs and collapsing the task display when the work finishes. The running overview shows delegation in progress; it is not a completed implementation result.

### Separate contexts inside one VM

[9:26](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=566s)

The process-level version exposes a different interaction model. Subagents appear as a stack at the bottom of a single agent window. Clicking a worker opens another chat window, giving the user access to that worker’s context. The execution remains inside the original VM even though the conversations are separated.

| Property | Process-level subagents | Separate-VM subagents |
|---|---|---|
| Execution location | One shared VM | Distinct VMs |
| Interface | Worker stack within one agent window | Separate environment entries |
| Inspection | Open a worker’s chat context | Inspect a worker’s environment and task |

Both arrangements divide work among agents. Their distinction is where execution is isolated and how that structure becomes visible to the user.

### A lifecycle stage hides many decisions

[10:20](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=620s)

Bichard’s own software-factory experiment asks whether he can build a project without touching any lines of code while making development as autonomous and self-directed as possible. He connects the experiment to Symphony and OpenAI’s harness-engineering work. His answer is that the technology can support this kind of attempt, but doing so exposes complexity that a conventional lifecycle diagram hides.

A five-stage SDLC is a useful human summary, but it is too coarse to specify everything an agent must do. Planning alone contains many smaller steps. The expanded Plan slide makes that visible through ticket breakdown, dependencies, and scope, each with a corresponding gate. An agent needs more than the name of the stage: it needs the work inside that stage broken into actionable steps.

![“The SDLC is not five steps” slide shows Plan, Develop, Test, Review, and Ship above an expanded Plan panel listing ticket breakdown, dependencies, and scope with corresponding gates.](https://ai.engineer/api/talk-essay-media/96a8f7ab9461fda4bd698fe11be34c257551b1abcb8e323e5eee02d496b92774)

Inside Plan: three micro-steps with explicit gates.

This decomposition applies throughout the lifecycle. The engineering problem is then to make agents follow those steps reliably and make progression sufficiently deterministic. Starting another worker does not establish that its prerequisites were satisfied, or that the previous worker actually finished the required work.

### Context loss turns supervision into a noisy queue

[11:43](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=703s)

Context makes that reliability difficult. As the context window fills, Bichard describes agents losing track of their direction and becoming less effective—**context rot**. They may also skip required steps. His example is an agent asked to write tests that omits some testing while trying to finish the task, behavior he connects to sycophancy and the desire to satisfy the request.

Once runtimes and orchestration exist, these failures become coordination problems. GitHub can hold the pull request, but a human may still need to review it, resolve a merge conflict, and repair CI. Across many agents, those signals become overwhelming: the person supervising the system has to work out where intervention is actually necessary. Bichard therefore argues that GitHub is a poor agent coordination layer.

He makes a similar criticism of using Linear underneath Symphony: tools designed for human work tracking are being stretched into agent coordination systems. The issue is not whether they can record tasks. It is whether they give agents and their supervisors a sufficiently precise way to manage progress through the development process.

### Make progression an explicit operation

[12:59](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=779s)

Bichard proposes combining several established ideas into a coordination layer:

- **State machines** represent the workflow and its allowed progression through the SDLC.
- **Durable execution** contributes mechanisms for maintaining a process over time.
- **Gates and compliance checks** determine whether work may proceed.
- **CLI packaging** makes the machinery available both in a local development environment and remotely in CI.

This is a proposed direction, not a demonstration of a finished coordination product. Its purpose is to put the lifecycle’s rules somewhere an agent can invoke them, rather than relying entirely on its current conversation to remember and obey them.

The intended human role is **on the loop**: able to supervise and intervene without driving every individual change. Bichard identifies context management as the hardest part of building this system. He regards runtime, orchestration, and triggers as effectively solved primitives, with coordination still missing. Security remains a separate obstacle to increasing automation, even after an execution environment has been chosen.

To make these ideas more concrete, Bichard announces a May 6 virtual summit on software factories and background agents, with attendance information and a call for proposals on his Background Agents site. He invites people already experimenting with these systems to contribute. Responding to feedback that software-factory talks are too theoretical, he also announces a plan to build one from scratch in public with Zach from Ona, starting the following week and running for two weeks. These are plans announced at the event, intended to expose the actual workflows and their rough edges.

### An agent asks whether it may advance

[15:34](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=934s)

An audience question asks for a more concrete remedy for coordination and memory problems. Bichard says Ona has several internal prototypes. He describes graph-based workflows, with prompts attached to a structure resembling Mermaid diagrams or n8n workflows, but favors packaging the capability as a CLI.

A local coding agent such as Claude Code would invoke that CLI through its tools. The operation would answer two related questions: has the agent achieved the current part of the SDLC, and may it proceed to the next part? This is the concrete shape of the proposed gateway: **advancement becomes a checked operation rather than an agent’s declaration that it is done.**

![Slide titled “We’re closer than you think” lists state machines, durable execution, gates, and packaging as a composable, scriptable, version-controlled CLI.](https://ai.engineer/api/talk-essay-media/03e3af4af3f8e547e097fa393cdf5d6720edcbcfd7928a82c584a1da0e9069ce)

Proposed coordination primitives: state machines, durable execution, gates, and a CLI.

For example, a small TypeScript gate can express the distinction between requesting advancement and being allowed to advance. Here, a test run has been requested but its evidence is still pending, so the state remains `test`:

```typescript
type Stage = "test" | "review";
type TestEvidence = "pending" | "failed" | "passed";

type WorkItem = {
  id: string;
  stage: Stage;
  tests: TestEvidence;
};

function requestReview(item: WorkItem): {
  item: WorkItem;
  allowed: boolean;
  reason: string;
} {
  if (item.stage !== "test" || item.tests !== "passed") {
    return {
      item,
      allowed: false,
      reason: "Advancement requires passing test evidence.",
    };
  }

  return {
    item: { ...item, stage: "review" },
    allowed: true,
    reason: "Test gate satisfied.",
  };
}

const work: WorkItem = {
  id: "coverage-change",
  stage: "test",
  tests: "pending",
};

console.log(JSON.stringify(requestReview(work), null, 2));
```

This illustrates the gateway’s decision boundary, not Bichard’s internal implementation. A real coordinator would also need a trustworthy source of evidence and a way to persist the transition. The agent’s request alone cannot establish that the gate has been satisfied.

Bichard offers to share a full specification after the talk. He places his CLI gateway alongside graph workflows and other interim approaches, rather than presenting one settled design. He tentatively names [OpenClaw’s `acpx`](https://github.com/openclaw/acpx), built on ACP, and mentions a nascent project called [Fabro](https://github.com/fabro-sh/fabro). These references describe the emerging landscape; they do not establish that his prototype uses either project. His response makes the workflow interface more concrete, but does not describe a memory-storage or retrieval mechanism.

### The open question is the coordination contract

[17:38](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1058s)

The final question asks whether the CLI uses a protocol such as ACP or A2A. Bichard says his implementation does not currently use an agreed protocol. He is still deciding whether to release an implementation or a standard, and is more interested in collaborating on the standard than in the particular implementation. ACP remains a possible future foundation, but the prototype is not built on it at the time of the talk.

Asked explicitly about A2A, he confirms that the prototype does not use that either. He sees the gateway as addressing a somewhat different problem space. The unresolved contract is how an agent establishes that development work has reached a valid state and obtains permission to continue. That is the missing primitive the talk leaves open for collaboration.

## Resources

- [Stripe’s Minions](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents) — Stripe’s account of its internal coding-agent system.
- [Harness engineering](https://openai.com/index/harness-engineering/) — Ryan Lopopolo explains repository guidance, feedback loops and enforced constraints for agent-driven software development.
- [OpenAI Symphony](https://github.com/openai/symphony) — An experimental service that turns tracked project work into isolated coding-agent runs.
- [Symphony Service Specification](https://github.com/openai/symphony/blob/main/SPEC.md) — A language-independent specification for scheduling coding agents, managing workspaces and configuring repository workflows.
- [OpenClaw acpx](https://github.com/openclaw/acpx) — A headless command-line client for stateful Agent Client Protocol sessions.
- [Fabro](https://github.com/fabro-sh/fabro) — An open-source system for defining and executing software-development workflows with agents.
- [Defining workflows in Fabro](https://docs.fabro.sh/core-concepts/workflows) — Graphviz-based workflow definitions combining agent steps, shell commands, loops and human decisions.

## Slides

### AI Engineer Europe

[0:00](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=0s) [AI Engineer Europe logo on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/099222ed3a40508baa117281b8765de70d74bc7dbd514791aa20e7c7d38d1c4f.webp)

AI Engineer
EUROPE

### Presenting Sponsor

Google DeepMind is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=5s) [Google DeepMind presenting sponsor card.](https://assets.ai.engineer/sites/aiecode2025/sha256/94b8a83e75af54cd32eb742cc8be01b92271ca2d2903fa413c8fdc796bc24862.webp)

PRESENTING SPONSOR
Google DeepMind

### Platinum Sponsors

[0:10](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=10s) [Platinum sponsors Braintrust, WorkOS and OpenAI.](https://assets.ai.engineer/sites/aiecode2025/sha256/70b4b05c03200b1d9c5b8843396840b004323a83f48b3c3c47d5ca7d7fa8dde2.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### Lou Bichard

Lou Bichard is Ona’s Field CTO. Previously a principal and platform engineer and product manager, he now works with customers while Ona builds a platform for background agents.

[0:31](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=31s) [Speaker introduction for Lou Bichard, Field CTO at Ona, with a portrait and short biography.](https://assets.ai.engineer/sites/aiecode2025/sha256/ca7864f768d612d5a8b4177403b95fe50705f40f8cb627b5ba22bcb1aa1272e3.webp)

SPEAKER
Lou Bichard
Field CTO · Ona

Former principal engineer and product manager. Building the platform for background agents.

ONA
ona.com
2 / 37

Interface text:
AIE
AI Engineer EUROPE
Google DeepMind

### Everyone is trying to build a software factory

Bichard’s software factory gradually moves the human from in the loop to on the loop, so work can progress from planning through deployment while the human is away from the computer.

[1:01](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=61s) [Software factory definition above an illustrated pipeline covering plan, code, review, test and deploy.](https://assets.ai.engineer/sites/aiecode2025/sha256/c8df76dd53f2f20d36cb3d5b3284f1ea4f0d66465e35a3050dae6d93dc0376b2.webp)

THE VISION
Everyone is trying to build a software factory

DEF. A commitment to incrementally moving the human from in the loop to on the loop across the SDLC — such that work happens proactively when the human is not at the computer.

PLAN   CODE   REVIEW   TEST   DEPLOY

ONA
ona.com
3 / 37

Interface text:
3 / 37 · Press Esc to exit
AIE
AI Engineer EUROPE
Braintrust   WorkOS   OpenAI

[1:16](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=76s) [A definition of a software factory above an illustrated pipeline from planning through deployment.](https://assets.ai.engineer/sites/aiecode2025/sha256/102b1bbfd38d96aa03a0fa6fd2c5142b052ca0ad08296b99aac2d124935bd66a.webp)

THE VISION
Everyone is trying to build a software factory

DEF. A commitment to incrementally moving the human from in the loop to on the loop across the SDLC — such that work happens proactively when the human is not at the computer.

PLAN   CODE   REVIEW   TEST   DEPLOY

ONA
ona.com
3 / 37

Interface text:
3 / 37 · Press Esc to exit
AIE
AI Engineer EUROPE

### Background Agents

Swarms fan one intent out to agents and converge on a result; fleets run independent work across repositories. Other agents respond to events or run on recurring schedules.

[1:48](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=108s) [Four panels describe swarms, fleets, event-driven agents, and scheduled agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/065a970a5cfa01858ee879a76d30ea633a4ceedba0598747c5425cc07826fcb3.webp)

Background Agents
background-agents.com

SWARMS
Converge on one result from multiple angles

FLEETS
Independent parallel work across repos

EVENT-DRIVEN
EVENTS   AGENTS   CONTRIBUTIONS
PR events, CI failures, webhooks, monitoring alerts

SCHEDULED
SCHEDULES   CONTRIBUTIONS
Cron jobs — nightly updates, weekly audits, daily triage

ONA
ona.com
4 / 37

Interface text:
4 / 37 · Press Esc to exit
AIE
AI Engineer EUROPE

### Minions: one-shot, end-to-end coding agents

Stripe’s Minions combine isolated devboxes, agentic and deterministic steps, and 400+ MCP tools. The slide reports ~1,300 human-reviewed PRs per week with zero human-written code.

[3:08](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=188s) [Stripe case study describing Minions, isolated development environments, blueprints, and coding tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/785e5b63dda90face5e19642f7b6ca54a6296c6fec2c1a1c2564552eafadb716.webp)

CASE STUDY · STRIPE

Minions: one-shot, end-to-end coding agents

~1,300 PRs/week. Human-reviewed, zero human-written code.

— Isolated devbox per run — 10s spin-up, same tools and CI as humans.
— Blueprints: agentic loops + deterministic steps (linters, tests, git).
— 400+ MCP tools via "Toolshed" — docs, tickets, code intelligence.

stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents

Embedded screenshot:
pay-server
Create a dev-only frontend for managing Google ...
Completed

Now I need to update the model to store scopes instead of just readonly.

File read
[illegible]

I see the model currently uses readonly boolean. For backward compatibility, let me add a scopes property and a method to get the granted scopes. Let me patch the model.

File edit
[illegible]

15 files modified in the working directory
[illegible]

Interface text:
Create pull request
Exit fullscreen
Expand all
Collapse all
ONA
ona.com
5 / 37
AIE
AI Engineer EUROPE 2026
Engineering the future of AI

### Ramp Inspect background agent

Ramp’s Inspect runs background agents in sandboxed VMs with a full development stack and integrations. The slide says Inspect writes ~30% of merged PRs.

[3:33](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=213s) [Slide describing Ramp’s Inspect agent, its development environment and integrations.](https://assets.ai.engineer/sites/aiecode2025/sha256/6e3cdf53ef282e0a62a15453c1dbcc25df09e7976f44c3fa46c2e013d57889f2.webp)

CASE STUDY · RAMP

Inspect: background agent with full dev context

~30% of merged PRs written by Inspect.

— Sandboxed VM on Modal — full stack per session (Vite, Postgres, Temporal).
— Wired into Sentry, Datadog, LaunchDarkly, Buildkite, GitHub, Slack.
— Image snapshots rebuilt every 30 min — near-instant start.

builders.ramp.com/post/why-we-built-our-background-agent

Interface text:
Inspect
Search sessions...
[illegible]
Ramp Inspect
Merges past week: 1,307
Authors past week: 202
Humans past week: 275
ONA
ona.com
6 / 37
AIE
AI Engineer EUROPE

### Ona platform for background agents

Ona gives agents isolated cloud development environments and can trigger background work on schedules or events. The speaker cites CVE remediation and increasing test coverage across repositories as examples.

[3:47](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=227s) [Slide describing isolated cloud environments, background tasks and agent automations.](https://assets.ai.engineer/sites/aiecode2025/sha256/952d53b1a7fc20cd098587a906755fad73cb05c9f6d42acd59b0248ad1a3ce9e.webp)

ONA · THE PLATFORM FOR BACKGROUND AGENTS

This is what we've been building

Ona gives every agent a full cloud development environment — the same workspace a human engineer would use.

— Parallelize tasks in the cloud — spin up isolated environments per agent, per task.
— Push work to the background — agents run autonomously while you context-switch to other work.
— Run agents as automations — trigger on PR events, schedules, or webhooks. No human needed to start the loop.
— Built on the dev container standard — same config for humans and agents.

ona.com

Interface text:
ONA
Home
Projects
Insights
What do you want to get done today?
[illegible]
ona.com
7 / 37
AI Engineer EUROPE

### Event-driven agent workflows

Ona Automations chains prompts, scripts, and PR creation into workflows triggered by events, schedules, or manual runs. Each execution gets a fresh cloud development environment.

[4:35](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=275s) [Slide showing an automation workflow and describing triggers, steps and isolated execution environments.](https://assets.ai.engineer/sites/aiecode2025/sha256/9314081fbfc4ef9f45cfd5895e68197b9abc14e4c131464e965f215059872e0d.webp)

ONA AUTOMATIONS
Event-driven agent workflows

Define multi-step agent workflows that trigger on PR events, schedules, or manually. Each run gets an isolated environment.

— Triggers — PR opened, cron schedule, webhook, or manual.
— Steps — chain agent prompts, shell commands, and PR creation.
— Each execution runs in a fresh cloud development environment.

Interface text:
Automations › Docs sync agent
[illegible]
Executions  Definition
Trigger
Scheduled weekly on Monday at 1:30 AM UTC
Runs across 1 project
10 concurrent and Max 100 actions per batch
Runs as Ona Automations
Prompt
You are a documentation specialist for Ona. Your task is to analyze ...
Shell Script
$ #!/bin/bash...
Prompt
Based on your analysis from Step 1, now generate the actual documentation updates...
Pull request
ONA
ona.com
8 / 37
AIE
Engineering the future of AI
AI Engineer EUROPE 2026

### Limits of agent knowledge

OpenAI’s Harness Engineering diagram shows Google Docs, Slack messages, and tacit knowledge as unseen by Codex. Encoding that knowledge as Markdown in the codebase makes it available to the agent.

[4:46](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=286s) [Diagram showing that knowledge outside the codebase can be encoded as Markdown for an agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/24f761538f68319e75d588006b41e9a51c01a47e52da19325e37f4547c1d923d.webp)

OPENAI
Harness Engineering

The limits of agent knowledge:
What Codex can’t see doesn’t exist

CODEX’S KNOWLEDGE

Unseen knowledge to Codex

Encode into codebase as markdown

Google doc
This document outlines our approach to feature prioritization and planning.

Slack message
We will follow @PaulM’s guidance on security posture from now on.

Tacit knowledge
Ryan is responsible for the overall architectural direction of the system.

…

openai.com/index/harness-engineering
ona.com
9 / 37
ONA

Interface text:
AIE
AI Engineer EUROPE
Engineering the future of AI

### Harness engineering in practice

Harness engineering spans repository context, guardrails, tests and tooling. The speaker describes a feedback loop: find where agents get lost, then encode that knowledge back into the repository or context.

[5:04](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=304s) [Four columns of practices covering documentation, guardrails, testing and development tooling.](https://assets.ai.engineer/sites/aiecode2025/sha256/2a133d08d1e07590a329d367a1ca19230cc69597ebad392314d8f974e9d319c9.webp)

What does harness engineering look like in practice?

DOCUMENTATION & CONTEXT
• Skills / reusable prompt workflows
• AGENTS.md
• Architecture decision records
• Runbooks
• API contract docs (OpenAPI / protobuf)
• README with setup & run instructions
• Changelog with migration notes
• On-call playbooks
• CODEOWNERS

GUARDRAILS & ENFORCEMENT
• Linters (ESLint, golangci-lint, ruff)
• Formatters (Prettier, gofmt, Black)
• Type checking (TypeScript strict, mypy)
• Pre-commit hooks
• Commit message conventions
• Branch protection rules
• Required CI checks before merge
• Dependency allow-lists / deny-lists
• License compliance scanning
• Secret scanning (truffleHog)
• SAST / static analysis gates
• Max complexity limits
• Import boundary enforcement

TESTING & FEEDBACK LOOPS
• Unit tests
• Integration tests
• Snapshot / golden-file tests
• Contract tests (Pact)
• End-to-end tests (Playwright)
• Visual regression tests
• Test coverage thresholds
• Mutation testing
• Load / performance benchmarks
• Flaky test quarantine
• Structured CI output
• Deterministic test fixtures
• Smoke tests for deploys

ENVIRONMENT & TOOLING
• Devcontainer config
• One-command setup (make dev)
• Seed scripts for local databases
• MCP servers for external tools
• Scoped secrets per environment
• Preview environments per PR
• Hot-reload / watch mode
• Structured logging (JSON)
• Observable traces and metrics
• Feature flags with local overrides
• Database migration tooling
• Dependency update automation
• Reproducible builds (lockfiles)

ONA
ona.com
10 / 37

Interface text:
10 / 37 · Press Esc to exit
AIE
AI Engineer EUROPE
Engineering the future of AI

[5:29](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=329s) [A four-column list of documentation, guardrails, testing, and environment practices for harness engineering.](https://assets.ai.engineer/sites/aiecode2025/sha256/f7286d47c3bbfa5e34b268c7c7d493c60b6d591445856217cdac1a98ff225c6e.webp)

What does harness engineering look like in practice?

DOCUMENTATION & CONTEXT
• Skills / reusable prompt workflows
• AGENTS.md
• Architecture decision records
• Runbooks
• API contract docs (OpenAPI / protobuf)
• README with setup & run instructions
• Changelog with migration notes
• On-call playbooks
• CODEOWNERS

GUARDRAILS & ENFORCEMENT
• Linters (ESLint, golangci-lint, ruff)
• Formatters (Prettier, gofmt, Black)
• Type checking (TypeScript strict, mypy)
• Pre-commit hooks
• Commit message conventions
• Branch protection rules
• Required CI checks before merge
• Dependency allow-lists / deny-lists
• License compliance scanning
• Secret scanning (truffleHog)
• SAST / static analysis gates
• Max complexity limits
• Import boundary enforcement

TESTING & FEEDBACK LOOPS
• Unit tests
• Integration tests
• Snapshot / golden-file tests
• Contract tests (Pact)
• End-to-end tests (Playwright)
• Visual regression tests
• Test coverage thresholds
• Mutation testing
• Load / performance benchmarks
• Flaky test quarantine
• Structured CI output
• Deterministic test fixtures
• Smoke tests for deploys

ENVIRONMENT & TOOLING
• Devcontainer config
• One-command setup (make dev)
• Seed scripts for local databases
• MCP servers for external tools
• Scoped secrets per environment
• Preview environments per PR
• Hot-reload / watch mode
• Structured logging (JSON)
• Observable traces and metrics
• Feature flags with local overrides
• Database migration tooling
• Dependency update automation
• Reproducible builds (lockfiles)

ONA
ona.com
10 / 37

Interface text:
10 / 37 · Press Esc to exit
AIE
AI Engineer EUROPE

### What a software factory needs

The slide identifies coordination as the missing layer: it governs work, tracks progress, enforces gates and manages state alongside runtimes, orchestration and triggers.

[6:05](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=365s) [Four panels describe agent runtimes, orchestration, triggers, and coordination.](https://assets.ai.engineer/sites/aiecode2025/sha256/766e5a51142f61606d29110393de4a4b594727ccb928090ca6752668446bdc24.webp)

What a software factory needs

Agent Runtimes
Where agents execute — environments, filesystems, tools. The sandbox market is blowing up.

Orchestration
Kick off agents, manage workflow runs. Ona Automations, GitHub Actions, Cursor Cloud.

Triggers
Start agent sessions in response to events — cron, PR events, webhooks, manual invocation.

Coordination
The missing layer. Governs what work should happen, tracks progress, enforces gates, manages state.

ONA
ona.com
11 / 37

Interface text:
11 / 37 · step 4/4 · Press Esc to exit
AIE
AI Engineer EUROPE
2026

### Runtime approaches

Isolation progresses from shared memory in threads to full VMs in dev environments, which also provide a full toolchain and per-agent secrets. Ona favors VMs for development tasks on security grounds.

[6:16](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=376s) [A table compares threads, worktrees, containers or microVMs, and development environments across six operational characteristics.](https://assets.ai.engineer/sites/aiecode2025/sha256/79a591440c850ab41083fc4e42cad8e1a70454053b2f6a1fed32e17b515e8483.webp)

COMPARISON
Runtime approaches

Threads | Worktrees | Containers / microVMs | Dev Environments
Isolation: None — shared memory | Git-level only | Process + filesystem | Full VM isolation
Tooling: Host tools | Host tools | Minimal | Full dev toolchain
Secrets: Shared | Shared | Manual injection | Per-agent provisioning
IDE access: Possible | Possible | No | Yes
Coordination: In-process | Git branches | Network | Orchestration layer
Lifecycle: Thread pool | Manual cleanup | Container runtime | Managed by platform

ona.com
12 / 37

Interface text:
ONA
AIE
AI Engineer EUROPE
2026

### Building the Software Factory: deck overview

Lou Bichard returns to the deck’s opening slide before introducing a recorded Ona interface demo.

[7:04](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=424s) [A browser displays the talk’s deck overview and its opening slide about agent swarms.](https://assets.ai.engineer/sites/aiecode2025/sha256/ea509e625dda64d786bd775a7518672510723fed089849a16f9b01f617f6875c.webp)

SLIDE DECK
Building the Software Factory
AI Engineer Europe — London, April 8–10, 2026 · Speaker: Lou Bichard

ONA
The Missing Primitive(s) for Agent Swarms
PLAN   CODE   REVIEW   TEST   DEPLOY
ona.com
1 / 37

SPEAKER
Lou Bichard

Interface text:
Building the Software Factory
ONA
Present
AIE
AI Engineer EUROPE
Engineering the future of AI

### Setting up the VM sub-agent demo

The VM demo plans three parallel sub-agents, each with its own environment, Git state and filesystem. Bichard contrasts this with a separate task using sub-agents inside one VM.

[7:25](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=445s) [The Ona interface describes creating three sub-agents in separate environments and shows the setup checklist.](https://assets.ai.engineer/sites/aiecode2025/sha256/5ac3e2ccf0d9c7cb040821a371f841d501efd670439890b04f0123f99ab8ab1c.webp)

Implement symphony (VMs)

Build the orchestrator script that spawns 3 sub-agents in separate environ... Postponed
Run the orchestrator and verify all 3 sub-agents complete their work Postponed

Let me check what project/environment setup we have available, and look at the existing WORKFLOW.md for reference.
Read elixir/WORKFLOW.md
Listed environment classes

Now I have everything I need. Let me design the approach:

Symphony via Ona sub-agents: Instead of using local workspaces + Codex subprocess (as the spec describes), each “issue” gets its own Ona environment with a sub-agent. This maps perfectly to Symphony’s isolation model — each issue gets a fully isolated environment with its own git state, filesystem, and agent.

I’ll use the current project ([illegible]) to spawn 3 sub-agents, each in their own environment, simulating 3 Linear issues being worked on in parallel.

TODOS (CONTINUED) 4/5
Understand the full Symphony spec and design the sub-agent approach
Create 3 mock Linear issues as local JSON files to simulate the issue tracker
Create a WORKFLOW.md with prompt template for the agents
Spawn 3 sub-agents in separate environments, one per issue
Wait for all 3 sub-agents and collect/synthesize results

Interface text:
ONA
Experiments
Update
New Environment
Home
Projects
Automations
CFPs - Call for paper submissions
Background-agents.com microsite
Ona Analytics
swarms-talk
Symphony
Implement symphony (Process)
4/4 Plan the Symphony implementation in Pytho[illegible]
Implement symphony (VMs)
4/5 Spawn 3 sub-agents in separate environmen[illegible]
main
Open
Code
Changes
All Files
Comments
Review
Create PR
Search files...
Uncommitted
.devcontainer/
devcontainer.json
Dockerfile
symphony-demo/issues/
SYMP-101.json
SYMP-102.json
SYMP-103.json
Ports & Services
Tasks
Terminal
Ports
Add port
No open ports
Add a follow up task or command
Archive
Organization settings
ona.com
Louis Bichard
Last user message
Claude 4.6 Opus
Stop
Esc
00:00:00

AI Engineer Europe
Engineering the future of AI

### Three sub-agents in separate environments

The VM parent spawns three sub-agents, each in its own environment for a separate issue. Their sessions appear in the sidebar as the parent waits for results.

[8:23](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=503s) [The Ona interface reports three sub-agents spawned in isolated environments and shows their issue and language assignments.](https://assets.ai.engineer/sites/aiecode2025/sha256/3102395530a2c00b26eaf9dff7d8dd7a73e27538a90a6146d4eaa0ac8582010d.webp)

Implement symphony (VMs)

TODOS (CONTINUED) 5/5
Understand the full Symphony spec and design the sub-agent approach
Create 3 mock Linear issues as local JSON files to simulate the issue tracker
Create a WORKFLOW.md with prompt template for the agents
Spawn 3 sub-agents in separate environments, one per issue

Now spawning 3 sub-agents in parallel, each in its own isolated environment — one per issue. Each gets the full Symphony spec context and its specific issue task.

Spawned sub-agent: You are a Symphony worker agent handling issue SYMP-101. You are working...
Spawned sub-agent: You are a Symphony worker agent handling issue SYMP-102. You are workin...
Spawned sub-agent: You are a Symphony worker agent handling issue SYMP-103. You are workin...

All 3 sub-agents spawned, each in its own isolated environment:

Issue | Sub-agent | Environment | Language
SYMP-101 | [illegible] | [illegible] | Python
SYMP-102 | [illegible] | [illegible] | TypeScript
SYMP-103 | [illegible] | [illegible] | Go

Waiting for all 3 to complete (10 minute timeout).

Wait for all 3 sub-agents and collect/synthesize results
Thinking...

Interface text:
ONA
Experiments
Update
New Environment
Home
Projects
Automations
CFPs - Call for paper submissions
Background-agents.com microsite
Ona Analytics
swarms-talk
Symphony
Implement symphony (Process)
2/4 Spawn 3 sub-agents to implement in paralle...
Implement symphony (VMs)
5/5 Wait for all 3 sub-agents and collect/synthe...
New Session
Starting...
New Session
Starting...
New Session
Starting...
Archive
Organization settings
ona.com
Louis Bichard
main
Open
Code
Changes
All Files
Comments
Review
Create PR
Search files...
Uncommitted
.devcontainer/
devcontainer.json
Dockerfile
symphony-demo/issues/
SYMP-101.json
SYMP-102.json
SYMP-103.json
Ports & Services
Tasks
Terminal
Ports
Add port
No open ports
Add a follow up task or command
Pause
00:00:29
Last user message
Claude 4.6 Opus
Stop
Esc
AIE
AI Engineer
EUROPE
2026

### Starting parallel sessions

As the VM task starts three sessions in the sidebar, the process task plans three sub-agents in a shared environment. The speaker describes a parent agent coordinating the sub-agents and receiving their messages.

[8:36](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=516s) [The Symphony process task is visible as three VM sessions start in the sidebar.](https://assets.ai.engineer/sites/aiecode2025/sha256/92f1ef6166ef768b976947f7adbccf4e1d8f18beee653a2559b83ce81fc4be0c.webp)

Implement symphony (Process)

Read SPEC.md L1-100
Read SPEC.md L100-200
Read SPEC.md L200-350
Read SPEC.md L350-500

I have a good understanding of Symphony now. Let me read the rest of the spec to understand the orchestration loop and agent runner details.

Read SPEC.md L500-650
Read SPEC.md L650-800

I now have a thorough understanding of Symphony. Let me see the elixir reference implementation briefly, then plan the implementation.

Read elixir
Read elixir/lib

Now I have enough context. Let me plan and execute this using three sub-agents.

TODOS 2/4
Plan the Symphony implementation in Python, decomposed across 3 sub-age...
Spawn 3 sub-agents to implement in parallel: (1) Core domain + config, (2) Orc...
Now spawning all three sub-agents in parallel. Each works on non-overlapping files in the shared environment.
Integrate sub-agent outputs and verify the implementation runs
Summary and demo

Interface text:
ONA
Experiments
Update
New Environment
Home
Projects
Automations
CFPs - Call for paper submissions
Background-agents.com microsite
Ona Analytics
swarms-talk
Symphony
Implement symphony (Process)
2/4 Spawn 3 sub-agents to implement in paralle...
Implement symphony (VMs)
4/5 Spawn 3 sub-agents in separate enviro...
New Session
Starting...
New Session
Starting...
New Session
Starting...
Archive
Organization settings
ona.com
Louis Bichard
main
Open
Code
Changes
All Files
Comments
Review
Create PR
Search files...
Uncommitted
.devcontainer/
devcontainer.json
Dockerfile
symphony_py/
__init__.py
Ports & Services
Tasks
Terminal
Ports
Add port
No open ports
Add a follow up task or command
Last user message
Claude 4.6 Opus
Stop
Esc
00:00:15
AIE
AI Engineer
EUROPE

### Symphony in isolated environments

The parent agent starts three sub-agents, each in a separate Ona environment for a mock Linear issue. They pass messages back to the parent, which governs the overall task.

[8:41](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=521s) [The VM task describes assigning each issue to a separate environment and sub-agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/101b4cb8794f1ce8fb1e3d118370e63d441da3eeb172660bba1882f62529ded9.webp)

Implement symphony (VMs)

Run the orchestrator and verify all 3 sub-agents complete their work — Postponed

Let me check what project/environment setup we have available, and look at the existing WORKFLOW.md for reference.
Read elixir/WORKFLOW.md
Listed environment classes

Now I have everything I need. Let me design the approach:

Symphony via Ona sub-agents: Instead of using local workspaces + Codex subprocess (as the spec describes), each “issue” gets its own Ona environment with a sub-agent. This maps perfectly to Symphony’s isolation model — each issue gets a fully isolated environment with its own git state, filesystem, and agent.

I’ll use the current project ([illegible]) to spawn 3 sub-agents, each in their own environment, simulating 3 Linear issues being worked on in parallel.

TODOS (CONTINUED) 4/5
Understand the full Symphony spec and design the sub-agent approach
Create 3 mock Linear issues as local JSON files to simulate the issue tracker
Create a WORKFLOW.md with prompt template for the agents
Spawn 3 sub-agents in separate environments, one per issue
All 3 sub-agents spawned, each in its own isolated environment:
Wait for all 3 sub-agents and collect/synthesize results

Interface text:
ONA Experiments
New Environment
Home
Projects
Automations
CFPs - Call for paper submissions
Background-agents.com microsite
Ona Analytics
swarms-talk
Symphony
Implement symphony (Process)
2/4 Spawn 3 sub-agents to implement in parallel
Implement symphony (VMs)
4/5 Spawn 3 sub-agents in separate environmen[illegible]
New Session — Starting...
New Session — Starting...
New Session — Starting...
Archive
Organization settings
ona.com
Louis Bichard
main
Open
Code
Changes
All Files
Comments
Review
Create PR
Search files...
Uncommitted
.devcontainer/
devcontainer.json
Dockerfile
symphony-demo/issues/
SYMP-101.json
SYMP-102.json
SYMP-103.json
Ports & Services
Tasks
Terminal
Ports
Add port
No open ports
Add a follow up task or command
Last user message
Claude 4.6 Opus
Stop
Esc
00:00:18
AIE
AI Engineer EUROPE

### Three isolated agents

The parent spawns three sub-agents in isolated environments, giving each the Symphony spec and a separate issue. The demo then waits up to 10 minutes for their responses.

[8:59](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=539s) [A table lists three issues and their isolated agents, environments, and programming languages.](https://assets.ai.engineer/sites/aiecode2025/sha256/f66a0c00dfad4fced28c26ef8ade60fe0df875f03c2587f2a3f613a19881997c.webp)

Implement symphony (VMs)

Understand the full Symphony spec and design the sub-agent approach
Create 3 mock Linear issues as local JSON files to simulate the issue tracker
Create a WORKFLOW.md with prompt template for the agents
Spawn 3 sub-agents in separate environments, one per issue

Now spawning 3 sub-agents in parallel, each in its own isolated environment — one per issue. Each gets the full Symphony spec context and its specific issue task.

Spawned sub-agent: You are a Symphony worker agent handling issue SYMP-101. You are working...
Spawned sub-agent: You are a Symphony worker agent handling issue SYMP-102. You are workin...
Spawned sub-agent: You are a Symphony worker agent handling issue SYMP-103. You are workin...

All 3 sub-agents spawned, each in its own isolated environment:

Issue | Sub-agent | Environment | Language
SYMP-101 | [illegible] | [illegible] | Python
SYMP-102 | [illegible] | [illegible] | TypeScript
SYMP-103 | [illegible] | [illegible] | Go

Waiting for all 3 to complete (10 minute timeout).
Wait for all 3 sub-agents and collect/synthesize r...
Waiting on three sub-agents · 10m
Waiting for 10m0s or three sub-agents to respond

Interface text:
ONA
Experiments
Update
New Environment
Home
Projects
Automations
CFPs - Call for paper submissions
Background-agents.com microsite
Ona Analytics
swarms-talk
Symphony
Implement symphony (Process)
2/4 Spawn 3 sub-agents to implement in parallel
Implement symphony (VMs)
Waiting on three sub-agents · 10m
New Session
Starting...
New Session
Starting...
New Session
Starting...
Archive
Organization settings
ona.com
Louis Bichard
main
Open
Code
Changes
All Files
Comments
Review
Create PR
Search files...
Uncommitted
.devcontainer/
devcontainer.json
Dockerfile
symphony-demo/issues/
SYMP-101.json
SYMP-102.json
SYMP-103.json
Ports & Services
Tasks
Terminal
Ports
Add port
No open ports
Describe your task or type / for commands
Last user message
Claude 4.6 Opus
Stop
Esc
00:00:37
AIE
AI Engineer
EUROPE

### Parallel process agents

Three process-level sub-agents work on separate parts of a Python Symphony implementation in a shared environment. Their statuses appear in the same window while the parent waits for their results.

[9:30](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=570s) [Three process-level sub-agents work in parallel while the parent task waits for their results.](https://assets.ai.engineer/sites/aiecode2025/sha256/e1f9fe09db73c1a0589b9ac88852f4d252fd1a7ed5a41e629f8ec6c0e46eeab1.webp)

Implement symphony (Process)

Read elixir
Read elixir/lib

Now I have enough context. Let me plan and execute this using three sub-agents.

TODOS 2/4
Plan the Symphony implementation in Python, decomposed across 3 sub-agents
Spawn 3 sub-agents to implement in parallel: (1) Core domai...
Waiting for 10m0s or three sub-agents to respond

Now spawning all three sub-agents in parallel. Each works on non-overlapping files in the shared environment.

Spawned sub-agent: ## Task: Implement Symphony Domain Model, Config Layer, and Workflow Loader You ar...
Spawned sub-agent: ## Task: Implement Symphony Issue Tracker Client, Workspace Manager, and Agent Run...

Now spawning the third sub-agent — the orchestrator, CLI, and status surface.

Spawned sub-agent: ## Task: Implement Symphony Orchestrator, Status Surface, and CLI Entry Point You are i...

All three sub-agents are running in parallel. Waiting for them to complete (10 minute timeout).
Waiting for 10m0s or three sub-agents to respond

Integrate sub-agent outputs and verify the implementation runs
Summary and demo

Implement Symphony Orchestrator, Status Surface, and CLI Entry Point — Working
Implement Symphony Tracker, Workspace Manager, and Agent Runner — Working
Implement Symphony Domain Model, Config, and Workflow Loader — Working

Interface text:
ONA
Experiments
Update
New Environment
Home
Projects
Automations
CFPs - Call for paper submissions
Background-agents.com microsite
Ona Analytics
swarms-talk
Symphony
Implement symphony (Process)
Waiting on three sub-agents · 10m
Implement symphony (VMs)
Waiting on three sub-agents · 10m
SYMP-103: Create Go Workspace Mana...
3/6 Create go/workspace/manager.go
SYMP-102: Write TypeScript Config Par...
3/6 Create typescript/src/types.ts with all interf...
SYMP-101: Add Python Reference Imple...
3/4 Create python/README.md
Archive
Organization settings
ona.com
Louis Bichard
main
Open
Code
Changes
All Files
Comments
Review
Create PR
Search files...
Uncommitted
.devcontainer/
devcontainer.json
Dockerfile
symphony_py/
__init__.py
config.py
models.py
Ports & Services
Tasks
Terminal
Ports
Add port
No open ports
Describe your task or type / for commands
Agent
Last user message
Claude 4.6 Opus
Stop
Esc
AIE
Engineering the future of AI

## Full transcript

[0:00](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=0s) [upbeat music] Cool. All right.

[0:15](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=15s) Hello, everyone. We're getting to the back end of the conference. I don't know if that's a good thing or not for you, uh, to start the weekend or maybe sad that the conference is over.

[0:21](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=21s) So gonna be talking about the, the missing primitive for agent swarms. So talking a bit about subagents and swarms within the context of, of coding agents and the infrastructure underneath them.

[0:32](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=32s) So just a quick introduction. So my name is Lou. I'm the field CTO at a company called Ona. Uh, previous life, I was principal engineer and sort of platform engineer, joined Ona doing product management, and now, um, I work a little bit more with our sort of customers on the field side.

[0:48](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=48s) So in my world at least, everyone is trying to build a form of a software factory. Uh, I've seen a few different talks at this conference of similar sort of ideas, trying to take coding agents and then apply them across the software development life cycle.

[1:00](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=60s) Uh, I'm, I'm wondering actually if this statement is entirely correct, 'cause I've definitely chatted to a lot of people, uh, over the course of this week that are not yet at this point of thinking about this.

[1:08](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=68s) Uh, but it's been very much, uh, occupying my head space for the last few months as well. So I added a definition in this slide as well, just to quickly define what I believe to be as a software factory, which is sort of the commitment to incrementally moving the human out of the loop, uh, within the SDLC,

[1:23](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=83s) uh, such that the human is not proactively, uh, interacting with a computer. I say that because I've seen a few talks and some people talking about software factory with these, like, parallel agents, like one individual IC running lots of coding agents at the same time.

[1:35](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=95s) It's not my personal definition. My personal definition is that you're slowly bringing the human out of it, and then work is flowing from sort of development into production, theoretically in an automated fashion.

[1:45](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=105s) But we're extremely early in terms of, uh, where we're at with software factories.

[1:50](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=110s) So obviously, there's a bunch of funky little visualizations that I've been showing, and a lot of these are actually taken from this website, backgroundagents.com, that I created, um, which seem to resonate quite a lot.

[2:01](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=121s) Um, so please do have a look at it. It encapsulates some of these ideas as well. But we have, like, different patterns really for running these agents at scale, uh, coding agents at scale.

[2:10](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=130s) So one of them really is sort of this swarm pattern, which, for my definition, is starting off with an, an individual intent, firing that out to a number of different agen-agents, and then funneling that back in, let's say, to an individual PR or task.

[2:22](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=142s) And that's almost like your typical kind of subagent process that we've, we've seen quite a few times. Uh, fleets is something... You, you can't see this very well in the room, unfortunately.

[2:31](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=151s) But on the top right, the sort of fleets is where you're fanning out agents across, let's say, a number of different repositories inside of an organization, uh, which is a capability we've had in Ona for quite some time now, and, uh, you see it a little bit popping up here or there, but not so much, but I

[2:45](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=165s) think it will be something that organizations will, will start to take advantage of, uh, a lot more in the future. And then at the bottom, you've kind of got events.

[2:53](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=173s) So if you think about how do we take the human out of the loop and build this sort of software factory, you need to know how and when are you going to trigger those agents?

[3:00](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=180s) When do they come online? And a lot of this already exists with existing sort of webhook infrastructure and things like that. PR is raised. Linear ticku-ticket is created, et cetera.

[3:11](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=191s) One thing that's been useful for us over the last couple of months is a lot of these large companies have also come forward and shared some of their implementations of this infrastructure.

[3:19](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=199s) So, uh, I'll, I'll mention a few notable ones. Uh, but Stripe has one. The, the- they're what they call Minions, which is built on top of their existing infrastructure where they've then plugged in these coding agents, and they're able to then drive thousands of pull requests inside of, inside of Stripe.

[3:34](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=214s) Another very noteworthy one, and Ramp has been so loud on social media these last couple of weeks, it's been quite insane. Uh, but they also built one that they internally call Inspect, which again is their sort of infrastructure for, for running these background agents.

[3:49](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=229s) And it's something that we've been doing now for quite some time. Um, so Ona as a platform has been infrastructure for development environments, uh, for about six years. But over the last year or two, obviously integrating further with the agent side of that as well.

[4:02](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=242s) What Ona effectively does is allow you to spin up a n- any number of different development environments, but one of the additional features that we have that I mentioned is this fleet feature.

[4:10](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=250s) So you can automate on schedules or triggers agents that spin up, uh, to resolve, uh, issues across a number of different repositories. Like, use cases for this is things like CVE remediation or bumping test coverage or enforcing something at scale.

[4:25](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=265s) As it stands today with current LLMs, that seems to be often tasks that are somehow simple, but the hard part is that you're doing this across a number of different teams, thousands of teams or thousands of repositories.

[4:38](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=278s) Which is the, what, what basically I'm showing you here. So it, it works kind of like a workflow kind of creation. You're adding prompts, scripts, and things like that, and then using that to, to drive this change across your organization.

[4:49](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=289s) I did want to give a notable shout-out also to the Harness Engineering blog that OpenAI and Ryan created, because this encapsulates much of this mindset of trying to then take and encode as much of your process into your repository, into your context files, your AGENTS.md, in order to build effectively that software factory.

[5:07](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=307s) Over the last couple of days, I had a few questions with people talking about harness engineering and what is it. Uh, for me, it's really another extension on context engineering whereby everything in your repository, from skills to AGENTS.md to unit tests, everything that you could possibly use to give feedback to your agent, uh, is for me harness

[5:23](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=323s) engineering. So I include this little visualization in the top corner 'cause as well for me, harness engineering is very much about doing things, letting the agent run through, figuring out where the agents gets lost, and then encoding that knowledge back into, uh, your repository or context, again, to try and get the agent flowing through the software factory

[5:40](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=340s) as much as it can. So if we take a step back and then think about from an infrastructure level what you need effectively to build this form of sort of software factory, the first piece of that puzzle is a runtime, or you need somewhere for the agent to run.

[5:53](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=353s) And I believe this mostly is, is pretty much a solved problem now. You then need a way to orchestrate these, so you need to run them at scale. So you need to, a way to run these agents, you know, scale up, scale down horizontally.

[6:04](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=364s) You need some way to trigger them, but for me, one of the biggest difficulties if you try and build this today is effectively agent coordination. So how do you get the agents to sort of interact with each other, pick up tasks from each other?

[6:15](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=375s) How do they collaborate? For runtimes, lots of, you know, different approaches here, but you can run agents as separate threads. You can isolate them more in worktrees. You can then go one step of abstraction further and put them in containers and VMs or microVMs, or what Ona does, basically, we really call these dev environments.

[6:34](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=394s) So, like, the sandbox conversation has made this very blurry, uh, but we at least believe that for running sort of proper development tasks, it has to be inside of a virtual machine.

[6:43](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=403s) The reason for that is, uh, for the isolation from a security standpoint, a container is not a bulletproof, um, isolation boundary. So if you have an agent running in there and you want to secure it, you're-- there's challenges for a container.

[6:56](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=416s) They're also bursty. If you run them on Kubernetes or in pods, you have noisy neighbor problems, you're gonna have compute contention across different containers. Uh, and only with having sort of the full isolation of a VM

[7:09](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=429s) will you be able to effectively do this properly. Let me run back through my presentation, sorry.

[7:17](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=437s) Cool. So let me actually just quickly... It's a good point, actually, at this point. I will show you a quick demo of how this actually looks inside of the Ona interface, because a lot of this is a little bit theoretical.

[7:25](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=445s) Um, I did a quick recording of this yesterday in my hotel room, just in case the Wi-Fi was terrible in here. But, um, let me just run you through this.

[7:32](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=452s) So in here, you see the Ona interface. On the left-hand side, you have all the different tasks that I have running. So I, I kicked off two different tasks here.

[7:40](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=460s) The first one I, I asked Ona to implement me Symphony. So Symphony has, uh, a spec in the repository that talks about how to implement Symphony. It's a very detailed spec, so I wanted to use it as an example.

[7:52](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=472s) I gave one of the agent and asked it to spin this up using process-based agents, uh, so subagents running within the environment itself. So take the VM, run the agent inside, and that agent will spin up subagents within that VM.

[8:03](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=483s) The other one I asked it to is effectively to run me a fleet with a number of different VMs. So the agent is actually then empowered to create other VMs inside of the platform, and it can spin up technically infinite of these.

[8:14](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=494s) So wherever you're running this, you're only really inhibited by as much as you're willing to pay and as much as your cloud provider can scale to. So if I run this through, what we see, and I might have to skip through here a little bit, is we see...

[8:28](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=508s) I jumped too fast. [laughs] Um, this bottom agent, the VM one, then it will spawn these three different subagents. So it spins up the different VMs, which we see coming in on the left-hand side.

[8:40](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=520s) The, the parent is the, the controlling agent, and the subagents obviously then are given small bits of context, individual tasks to complete, and then will do message passing back to that parent agent to control and govern the overall task itself.

[8:54](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=534s) One challenge for sure we have is the, how do we build the UX for this? Like, as you build more and more complicated tasks, how do you think about sort of managing and controlling these subagents, and how do you think about the UX on top of them?

[9:05](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=545s) So as this progresses, you'll see also on the left-hand side, eventually you start to see, um, as the agents come online, they start their environments, and they start to work through tasks.

[9:14](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=554s) Both of these have, for some reason, seven sort of sub items that they're working through, so you can see those. When that gets to the end, it's then obviously going to terminate those VMs.

[9:21](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=561s) That's all going to collapse down, and your task is, is complete.

[9:26](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=566s) The second form of UX for this that we have with the, the subagents is this one here with the process level, uh, which I'll pause so that it's not jumping around.

[9:34](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=574s) Um, when you launch a process-level subagent, it happens all within the single agent window. So you actually see at the bottom here a, a stack of a number of different subagents that are starting.

[9:44](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=584s) And then when you click on those, you can then open up a new chat window, which is almost your new context, and use that. So you've got this, like, two different forms of this, one entirely isolated VMs to scale out these swarms, and another one at the sort of process level where you can run it within the

[9:59](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=599s) individual VM itself. So lots of stuff going on there, but I wanted to show you conceptually, people say, "What does this swarm look like in, in, in reality? How does this actually look?"

[10:09](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=609s) And this is how it looks within, within Ona.

[10:16](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=616s) So give me one second to fly back through.

[10:20](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=620s) So coming back to the software factory idea. So how do I know, uh, about some of the challenges about software factories? And that is because I've also tried to build one.

[10:27](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=627s) Um, obviously, I implement many of these ideas in, in our own projects, but I also, similarly to what OpenAI did building out their sort of Symphony project and their harness engineering blog, is, okay, what-- can we build a project without touching any lines of code, and can we automate as much of this process as possible such that

[10:43](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=643s) the agent can actually then develop everything as autonomously and self-driven as possible? And it turns out, yes, the technology is there today, but there are some different challenges that you have.

[10:53](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=653s) What's missing? One thing that we-- you find out is that the SDLC is not this. It, you know, this is the conceptual SDLC that we present and talk about with each other, the very coarse-grained five steps of the SDLC.

[11:07](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=667s) Agents don't respect this, and they don't understand... I mean, these boxes contain a ton of complexity. So if we take something like plan or a plan stage, actually within that, our SDLC has a ton of different sort of micro-steps almost to it.

[11:19](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=679s) And if we're wanting them to train agents to then step through the SDLC, we need to find ways to actually break down the SDLC into these, some of these micro-steps.

[11:27](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=687s) And that happens all the way through the SDLC. So if you want to build some form of software factory, we then now need to start figuring out how to solve these sort of micro-steps.

[11:35](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=695s) How do we get agents to sufficiently follow those steps and do them in sort of deterministic ways as well?

[11:43](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=703s) And the hard part of this is context. Probably not a, you know, huge innovation to everyone in this room. Context windows are some of the hardest parts about working with LLMs because, as the last speaker said here as well, context rot.

[11:55](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=715s) Context, you know, once the context window becomes consumed, the, the agent starts to lose track of where it's going and things like that. It gets less effective. They also skip steps typically.

[12:05](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=725s) Um, you know, they want to please us. They're quite sycophantic, so they will might, you know, ask them to write some tests, and then they're going to skip some tests, um, in order to complete the task.

[12:16](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=736s) So a lot of the tools that we have today as well for coordinating these agents as you start to spin them up, once you've got this infrastructure, you have the runtimes, you have the orchestration.

[12:24](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=744s) The missing piece then you also need is coordination. So if you use something like GitHub, GitHub is not a coordination layer for agents. It gets incredibly overwhelming. You know, you can have your agents raise a pull request, you can review it, you can then solve the merge conflict, you can fix your CI build, et cetera.

[12:40](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=760s) But this gets incredibly noisy for you as a human to make sense of where you should step in to intervene with that agent itself. And GitHub is a, a poor solution for this.

[12:50](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=770s) Uh, Symphony is built on top of Linear, but suffers the same problem, that we're re- reusing existing sort of human tools in very weird ways for agents.

[12:59](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=779s) But I think we are now at the cusp of now effectively solving this, and I think it might be solved in a few different ways. One is, um, through sort of state machines, you know, by building out workflows and, uh, effectively state machines that we've had for a very long time, and then building these as our versions

[13:13](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=793s) of our SDLC. I do believe, to a degree, some of the ideas from Durable Executions comes into this as well. You know, lots of companies have pioneered this over time to be able to run a process in a, in a durable fashion.

[13:24](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=804s) Um, but we do need to solve also the gates and compliance, uh, section of this. And I do believe actually there is definitely a, a gap right now also for packaging this in some form of like CLI construct whereby you can run this locally in a sort of development environment, but also then remotely in, you know, in

[13:39](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=819s) a CI or some other fashion like this.

[13:44](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=824s) But that's effectively it. If anyone wants to, to chat and go a little bit deeper, I think we've got a couple of minutes. We can also take some, some questions if we need to.

[13:51](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=831s) Um, yes. Basically, my definition of software factory is moving this human on the loop so that they're not necessarily driving each of these d- individual changes. Context and context management is by far the hardest part of building this software factory.

[14:06](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=846s) Out of these primitives, I do believe we've effectively solved the runtime. There are many options for this now, sandboxes and, and containers and other solutions. The orchestration is effectively solved.

[14:15](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=855s) The triggers are solved. Um, but the thing that's missing for me is coordination. Uh, also, one of our folks here is here from, from our security team. Uh, and security is another piece of the, the puzzle that we really need to solve as well to, to drive more automation.

[14:28](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=868s) But it's this coordination layer that I think is, is largely what's missing.

[14:33](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=873s) Obviously, a lot of this is a little bit high level. On, on the 6th of May, we'll run a, a virtual summit to go into these topics, uh, about software, um, software factories and background agents.

[14:41](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=881s) So if anyone here would like to attend, uh, you can do. It's on backgroundagents.com, and there's... We have a CFP up for it as well. If anyone would like to speak, um, that would also be great.

[14:50](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=890s) There's not many people in the world doing this, so if you're at least experimenting with it, uh, it would be great to also to talk to you as well.

[14:57](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=897s) The other thing is a few people that I've been speaking to at the conference, especially about software factory, complain that obviously a lot of these talks are a little bit theoretical, which is true.

[15:05](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=905s) Uh, so some of you might want to be really getting into the weeds of this. So actually, next week, um, with Zach from Ona, we're actually just gonna build one of these in public, starting from scratch, build a software factory.

[15:15](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=915s) We'll, we'll do this over the course of two weeks in public just to show what that looks like with today's technology, um, just to really, like, show all the ins and outs of the workflows if anyone wants to see what that actually looks like as well.

[15:27](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=927s) But there you go. Thank you very much. Um, we do have two and a half minutes if anyone has questions, but if not, I'll also, um, be outside and downstairs.

[15:34](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=934s) Yes.

[15:34](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=934s) Thank you for the, the talk. Super helpful. Um, could you maybe, uh, go back to the slide where you were talking about the problems with the coordination layer?

[15:42](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=942s) Yep. Um-

[15:44](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=944s) With, um, memory, and then also if you could just elaborate a bit more on what you propose as a solution in more concrete, um, that would be pretty interesting to hear your thoughts.

[15:53](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=953s) Yeah, sure. So I have been... Uh, so I need to repeat the question actually for the, for the stream. So the question was, um, problems with the coordination layer and sort of more concreteness about the solution, what could that potentially look like?

[16:04](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=964s) So I have, um, we have a number of different sort of prototypes for this internally, and I've also been trying to think about how we... what we do with this.

[16:12](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=972s) So I think one form factor that, that works is the CLI. Um, so I've seen some other solutions, graph-based ones. There are some open source things right now where defining the workflow effectively as a, as a graph, um, you know, like kind of like what you drive sort of mermaid diagrams out of, like n8n type of, of

[16:30](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=990s) workflows, um, where you can define sort of these prompts in, in that form. Um, I think that ultimately needs to be packaged in some form of CLI, though. Um, what I mean by that is I think the...

[16:39](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=999s) If you have a local running agent, Claude Code, whatever, any local running CLI, I think that now needs to have something that integrates with its tools, so it can invoke this to say, "Hey, have I achieved this part of my SDLC, and can I now proceed to the next part of it as a, a CLI?"

[16:53](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1013s) If you want as well, I can-- I have a full spec for this I can show you, um, after the talk as well. We can go a bit deeper into it.

[16:59](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1019s) Um, but I'm seeing this solved in a number of different ways. People are solving this in, in a few different ways. There's the n8n sort of

[17:07](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1027s) workflow type of diagram way. The CLI sort of gateway of- is the prototype that I have as well. Um, and then there's an, a range of different sort of hacky interim solutions.

[17:17](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1037s) Uh, there's one even the OpenClaw folks have as well, which the name is eluding me, but I will... I think ACPX, which they've built on top of ACP, um, which builds out some of this workflow.

[17:27](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1047s) There's a GitHub one, Fabro, some folks are playing around with, but it's very nascent right now. Um,

[17:35](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1055s) yeah. Any other questions?

[17:38](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1058s) Are you using, uh, are you using some protocol for the CLI? Because, you know, ACP, there's ACP, there's A2A, there's a bunch of, uh... Yeah, I, I don't know if people have agreed on the, on the standards. [laughs]

[17:48](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1068s) Cu- currently not. So the inter- the implementation that I have, I'm trying to understand whether or not to release it as an implementation or as a standard, to be honest, because I largely kind of don't really care about the implementation.

[17:57](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1077s) I almost care about the, the standard for it, so we can collaborate on the standard. Um, but it's not built on top of ACP, or at least not yet, but it might be.

[18:05](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1085s) Um-

[18:06](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1086s) And it's not A2A either?

[18:07](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1087s) Not A2A either, no. It's solving, I feel, like a slightly different problem space, so...

[18:16](https://www.youtube.com/watch?v=5Sui_OnSRlY&t=1096s) Cool. All right. Thank you very much. Enjoy the conference, everyone. Thank you. [audience applauding] [upbeat music]
