# Your Team's Agents Are All Shipping to the Same Code at Once - Patrick Debois, Tessl

Patrick Debois, Tessl

[Talk page](https://ai.engineer/talks/fTUinMqA1XQ-your-teams-agents-are-all-shipping-same) · [Video](https://www.youtube.com/watch?v=fTUinMqA1XQ)

## Your Team’s Agents Are All Shipping to the Same Code at Once

A merge to main can send every waiting pull request back through CI. Patrick Debois explores what it takes to deliver changes concurrently, from checking whether two edits agree on invoice units to deciding when a stuck agent needs a person at the keyboard.

### The person at the center of a solo factory

[0:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=0s)

Several coding agents can work on one laptop and still leave one person with a demanding job. The developer remembers what each agent is doing, makes the decisions and merges the results. Patrick Debois of Tessl calls this a *solo factory*. Behind it sits a familiar delivery pipeline that builds, tests and takes changes through merge and release. That pipeline can automate a great deal while still moving changes in serial order.

Sharing context, skills and the loops that agents run lets colleagues reproduce a setup. The coordination problem changes when those colleagues put their setups to work at the same time. Their agents all want to merge into the same `main` branch. The people share a ticket board and need to know which changes are coming. The developer who could keep the whole plan in memory on a laptop now sees only part of it.

### One merge creates work for every waiting PR

[1:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=118s)

Debois estimates that incoming pull request volume can rise almost tenfold when a multiplayer factory starts up. What that buys the team depends on what reaches release. Two agents can keep each other busy by undoing each other’s changes. Both produce work for the merge queue while the code goes back to where it started.

Why does landing one change make the rest of the queue more expensive? Consider two other PRs waiting when the first one merges. Each was tested against the previous state of `main`. In the pipeline Debois describes, each now has to rebase, bringing its changes onto the new base, and typically rerun its tests. The two waiting branches incur that cost independently. As the queue grows, a single successful merge can trigger more CI work and a longer wait for release.

Features also compete for approval with fixes for agent incidents and maintenance of the factory itself. Someone has to review changes to the skills and loops that produce the next round of PRs. Debois uses *concurrent delivery* for the design problem this creates. Simultaneous work is frequent enough to plan for it before coding begins.

What happens to two waiting PRs when main advances?
Both paths start at the same merge. Each waiting PR checks its own changes against the updated base, so CI can repeat work even when neither author adds a feature.
- A PR lands on main — The base changes for the remaining PRs.
- Rebase B — Bring B’s changes onto the updated main.
- Retest B — Run B’s checks on that combination.
- Rebase C — Bring C’s changes onto the same updated main.
- Retest C — Run C’s checks on its combination.
- A PR lands on main → Rebase B (B’s base advances)
- A PR lands on main → Rebase C (C’s base advances)
- Rebase B → Retest B (typically reruns checks)
- Rebase C → Retest C (typically reruns checks)

### Claim the ticket, announce the files, isolate the work

[3:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=230s)

Authentication and payments suggest a natural split between two agents. A graph of the code can help identify pieces that actually separate well. Where two tasks come close together, the assignment can get more precise, down to a file, a function or even individual edits within a file. Doing this during planning reveals how much independent work there is before the agents start.

An agent claims a ticket on the board so another agent leaves that task alone. It also announces which files it expects to touch and what it plans to change. The announcement serves a different purpose from the claim. Two agents can each own a different ticket and still discover that their plans involve the same function. Publishing the intended edits gives them a chance to spot that overlap while they can still adjust the work.

Separate Git worktrees give agents their own working files. Isolation can extend to the things those files depend on. An agent can have its own machine and context, a fixed API version, a database snapshot and its own test data. Mocks or digital twins can stand in for outside systems. An agent can then run an experiment without another agent changing the data underneath it or the experiment affecting the outside world. The resulting code will still need to meet everyone else’s changes on `main`.

### When two agents reach the same code

[5:57](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=357s)

A collision during execution leaves a choice about the plan already in flight.

- **Wait and retry.** Let one agent finish the contested work, then give the other another attempt.
- **Requeue the task.** Return the waiting work to the queue until the work it depends on is done.
- **Renegotiate the split.** Change who does what while the agents are working. If they can agree on separate edits, both can continue.

If the overlap survives until merge time, one option is to rerun the work and try the merge again. An agent could also inspect the whole function containing the conflicting lines and attempt a repair that accommodates both edits. An agent that can see a neighboring change coming could go further and adapt its own code while the other change is still in progress. That possibility depends on knowing what the other agent intends to do.

![An arrow leads from shared resources to nested boxes for one agent’s machine snapshot, API twins, database branch, test data and private context. A return arrow requires review through a pull request.](https://ai.engineer/api/talk-essay-media/b6108e4a5b077507b848171284d0f826363a5db9d7970e14aea20b90bcf042fd)

Separate Git branches still leave agents with different views of shared task state.

### The invoice that merges cleanly and reports the wrong unit

[7:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=441s)

What unit does the report expect to receive? One PR changes the function that calculates an invoice total so it returns cents. At the same time, another PR changes how the total is reported. The reporting change still expects dollars. The edits can touch different lines and their tests can pass, yet the output of the calculation is the input to the report. A number calculated in cents would be read as a number of dollars.

Debois proposes having an agent compare the intents of the incoming PRs. For this pair, the agent would need to follow the total across the two changes and ask where the conversion to the report’s intended unit takes place. If the changes disagree about that responsibility, the agent has something specific to flag for a person or to correct in a PR.

### Check which changes can travel together

[8:20](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=500s)

If one PR fails to land, which others actually have to wait? A queue that processes each candidate in turn can leave the rest rebasing and redoing work after a failure. A *speculative merge train* looks ahead at the incoming PRs and checks candidates in pairs for compatibility. If one candidate drops out, the queue already has information about which other changes can go through together. Those candidates can advance while the troublesome one waits.

The train spends effort checking combinations ahead of time to reduce waiting later. What those checks establish depends on what they test. A train that only checks whether the invoice edits merge and pass their existing tests could carry the unit error straight through. Debois expects planning, merge handling and analytics for concurrent changes to become developer infrastructure in their own right as teams outgrow simple agent loops.

![A queue tests A, A+B and A+C in parallel. A+B fails, sending B back to rerun. A and C land on main, and a release train takes the batch through a deployment gate to production.](https://ai.engineer/api/talk-essay-media/03fc124ebd17f8e68e79bc38ed84527e838452649f3138542f9a954c0cc96098)

The train tests possible combinations in parallel while earlier changes wait to land.

### A conversation becomes a ticket the team can execute

[9:40](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=580s)

One shared board makes incoming changes and work in progress visible beyond the developer who started each task. Visibility also exposes a bottleneck. Several agents can ask for attention at once, and moving all their questions onto a board still leaves people answering them.

One way to put that attention to better use is to invite an agent into a conversation the team is already having. Several people can clarify the same request while the agent refines the ticket. The agent can ask what behavior they want, which requirements apply and what test would show that the work is done. The answers turn the ticket into something like a coding agent’s plan, available on the board for everyone to inspect.

Consider the old path for a request from sales, marketing or support. A colleague filed a ticket and could wait weeks for an engineer to pick it up. Building a quick version independently brought another problem when the result didn’t fit engineering practice. At Tessl, colleagues bring the agent into their organizational chat. They can experiment, refine the feature or start building it using engineering’s pipeline, knowledge, skills and loops. The support colleague who knows the original requirement can help settle what the feature should do while the idea is still taking shape.

![Three answers become checks on the ticket. The export must contain the columns finance needs, cover only the last 90 days and list refunds as negative rows.](https://ai.engineer/api/talk-essay-media/60e5954e5e644e1ae8f489290f83e061d66c36a9ea0f36fda3c6fef068f73e84)

Questions raised during planning become acceptance checks on the same ticket.

### Step into the stuck agent’s workspace

[12:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=774s)

What would you need in front of you to unblock an agent? When a ticket calls for rapid experimentation, another round of comments can be slow. In the handoff Debois describes, the stuck agent opens an IDE with its working context and files already available. A person can try an experiment there, make the missing choice and hand the work back. The agent resumes with the result of that intervention.

Some tasks only need a decision. The agent can present a few options, let a person pick one or override them, then continue. That saves the person from having to reconstruct the problem and write the next prompt from scratch. The choice goes into a shared decision log. A colleague can trace who decided what, and an agent in a later session can query the same decision when it needs that context.

### Size the change for its reviewer and its production risk

[15:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=906s)

There is a second reason to divide the work. A change can be isolated from other agents and still be too large for a person to review well. Smaller PRs can move through merge trains in pieces that reviewers can understand. Better context and tools can reduce failures before review, and another agent can challenge the code before a person sees it. Screenshots of a flow, video and test results give the reviewer a way to inspect what the change actually did.

When developers tell Debois they have stopped reading the code, his follow-up is about the impact of sending that change to production. An application with no customers has a different exposure from a service people rely on. Even within one application, the review decision can vary by change.

- **Documentation.** A limited-impact edit may go through after the applicable checks.
- **Authentication.** A mistake can have enough impact to justify closer human review before release.
- **A feature that can roll out gradually.** Release it in stages and inspect the output and errors as it reaches users.

Recovery changes that calculation too. If a release could lose data, how quickly could the team restore it? If one node fails, what happens to the service? How quickly could the team roll back a bad release? Review and testing can lower the likelihood of failure. Architectural choices about node failure, rollback and data restoration help determine how costly a failure will be once it happens.

### Who keeps up with the changes, and who owns the factory?

[18:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1083s)

Debois works remotely while most of his team gathers in London. He already had trouble catching up on changes discussed in the room. With several agents producing code, marketing and support can find themselves in much the same position. A list of merged PRs leaves them to work out the implications. Communicating a change in the language of each group’s work becomes part of delivering it.

The more routine work the agents handle, the more valuable it becomes to route an exception to someone who can decide it. Someone also has to maintain the system doing the routing. Debois sees a *factory team* emerging, much as a platform team might look after a cluster. Its responsibilities include establishing who owns each skill, keeping shared context up to date, connecting agents to the right components and monitoring the factory. An outdated instruction shared by the whole team has a different reach from one sitting on a single developer’s laptop.

The shared log gives an agent a way to recover a decision someone has already made. Debois’s team is exploring what happens when the board needs a new decision. A personal agent working there on someone’s behalf could answer another agent’s question and exercise the judgment that person has delegated to it.

## Key takeaways

- A ticket claim prevents duplicate work on that ticket. Announcing intended files and edits lets agents detect overlap between different tickets.
- Two passing PRs can disagree about the meaning of a value. Follow the invoice total from calculation to report and check which unit each change assumes.
- Match the handoff to the question. A stuck experiment may need a live workspace. A decision among known options may need only a choice and a shared record of the answer.
- Choose review depth using production impact and recovery cost as well as test results. Gradual rollout limits exposure, rollback reverses a release, and data restoration addresses loss that a rollback alone may leave behind.

## Slides

### Continuous delivery gave us the pipeline

The pipeline builds and tests three pull requests in parallel. At the merge step, your change enters main while the other two wait. Deployment follows from main.

[0:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=0s) [Three pull requests build and test in parallel, then queue to merge into main one change at a time before deployment.](https://assets.ai.engineer/sites/aiecode2025/sha256/9899339aee445b5553a5ca5a2c8994841d25eaf56f68afccedeef3761ea09225.webp)

WHERE WE COME FROM
Continuous delivery gave us the pipeline

PRs from people, at human pace

build → test
your PR → build → test
build → test
in parallel

waiting
merge to main
one at a time
the serial point
main → deploy

The pipeline runs in parallel. Integration into main is still one change at a time.

### Agents work together. People work with them.

Five agent paths converge on one main branch. Four people share a task board where they plan, steer, review and hand off the work their agents are running.

[1:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=95s) [On the left, five colored paths converge on one main branch. On the right, four people connect to one board to plan, steer, review and hand off agent work.](https://assets.ai.engineer/sites/aiecode2025/sha256/6b9cd7d48df904e6edb7fece78c741b9abc9d70c362b73a1aa9668f2d364e984.webp)

THE MAP OF THIS TALK
Agents work together. People work with them.

ACT 1 · AGENTS TOGETHER
One main.
main
Everyone’s agents, one codebase: they coordinate like a team.
split → claim → isolate → adapt → rerun → check reads → verify

ACT 2 · PEOPLE WITH AGENTS
One board.
People plan, steer, review and hand off work the agents are running.
start · join · decide · review · tell

The research behind both acts — concurrent.cd

### Conflict becomes routine in concurrent delivery

Pipeline delivery treats conflict as an exception. When people and agents share one main branch and one board, Debois argues that teams should build conflict handling into their everyday workflow.

[3:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=209s) [Under pipeline delivery, “exception” is crossed out. An arrow points to “routine” under concurrent delivery. The slide urges designing for conflict when people and agents share one main branch and one board.](https://assets.ai.engineer/sites/aiecode2025/sha256/2bbd0c5b2272cc8c806311738b474a3e1ec986a53d48bca24588bd6040a6bb1c.webp)

AGENTS TOGETHER · PEOPLE WITH AGENTS — THE SHIFT

PIPELINE DELIVERY
conflict is the exception

→

CONCURRENT DELIVERY
conflict becomes routine

So design for it.

Concurrent delivery: many writers, people and agents, sharing one main and one board.

The map — concurrent.cd

### A Git branch forks code. An agent forks a view of reality.

Each agent starts from a machine snapshot, calls replayable copies of external APIs, and creates test records on its own database branch. Its scratchpad stays private. Changes to the shared AGENTS.md go through pull request review.

[5:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=316s) [An arrow leads from shared resources to nested boxes for one agent’s machine snapshot, API twins, database branch, test data and private context. A return arrow requires review through a pull request.](https://assets.ai.engineer/sites/aiecode2025/sha256/b6108e4a5b077507b848171284d0f826363a5db9d7970e14aea20b90bcf042fd.webp)

A Git branch forks code.
An agent forks a view of reality.

AGENTS TOGETHER · PEOPLE WITH AGENTS — ITS OWN WORLD · NEW INFRA

Snapshots keep each agent in its own world.

the shared world
the running machine
real APIs: Okta, Slack, Stripe
production database
shared test data
shared AGENTS.md

snapshot, fork

machine   forked from a snapshot: disk + memory   E2B · forkd
outside world   API twins: stateful, replayable   StrongDM digital twins
database   its own branch, copy-on-write   Databricks Lakebase
test data   its own records, created and cleaned up
context   its own scratchpad; AGENTS.md via PR
A   one agent

back only
via review / PR

IN SHORT   The code is the easy part. Fork the machine, branch the data, twin the APIs, keep context private.

Databricks — databricks.com/blog · StrongDM — simonwillison.net/2026/Feb/7/software-factory · Lee — youtube.com/watch?v=[illegible] · E2B — docs.e2b.dev/sandbox/snapshots

### Merge trains test in parallel, so main keeps moving

The queue tests A, A+B and A+C in parallel. When A+B fails, A and C can land without waiting for B. B’s agent retries on the updated main, while the release train batches the merged changes for a separate deploy gate.

[8:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=498s) [A queue tests A, A+B and A+C in parallel. A+B fails, sending B back to rerun. A and C land on main, and a release train takes the batch through a deployment gate to production.](https://assets.ai.engineer/sites/aiecode2025/sha256/03fc124ebd17f8e68e79bc38ed84527e838452649f3138542f9a954c0cc96098.webp)

Merge trains test in parallel, so main keeps moving
AGENTS TOGETHER · PEOPLE WITH AGENTS — VERIFY · MERGE TRAINS

agent PRs
A
B
C

speculative queue
test the combinations in parallel
CI: A ✓
CI: A + B ✗
CI: A + C
B out
B fails: dropped, its agent reruns on the new main

main · A and C land
red anyway? an agent bisects and reverts

release train
batches what landed
deploy gate
prod
always protected

IN SHORT  Test A, A+B and A+C in parallel. A+B fails, so B drops out and reruns; A and C land, and the release train gates prod.

Korlam (Uber) — youtube.com/watch?v=7b9tov5Uc5s · talk summary — aiweeklyreads.substack.com/p/ai-weekly-reads-2026-10-18 · Celenza (GitHub) — github.blog/engineering · Anthropic — anthropic.com/engineering · Tools: Uber SubmitQueue · GitLab merge trains · GitHub merge queue · Mergify · Aviator · Trunk

### One board.

Most work can run solo. When a task needs several people, one shared board lets the team see which changes are coming, who’s doing the work, and who needs to decide, review, or hear about it.

[9:38](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=578s) [The word “board” is highlighted in lime above a prompt to follow who starts shared work, who joins, who decides, who reviews and who is told.](https://assets.ai.engineer/sites/aiecode2025/sha256/c22c65c21587932b7aa01c4f37c3d10f6cf71b26622f3fd7b6113953eb0f84ad.webp)

One board.

AGENTS TOGETHER · PEOPLE WITH AGENTS — ONE BOARD

Most work runs solo, on the team’s skills. Follow the work that can’t: who starts it, who joins, who decides, who reviews, who’s told.

### The agent joins the chat. The state lands on the ticket.

Raj tags the billing agent in the team’s chat. It opens BIL-142 and records Ana’s requirement to include refunds alongside Raj’s decision to ship CSV first and PDF later. Three questions remain before the plan and checks.

[10:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=621s) [An arrow links a billing chat to an export ticket. The ticket records two decisions from the chat: deliver CSV first and PDF later, and include refunds.](https://assets.ai.engineer/sites/aiecode2025/sha256/0a315405249d9c24c62d62e5c789f63e617d0d905825aae59df05b28b6a8d0d6.webp)

The agent joins the chat.
The state lands on the ticket.

AGENTS TOGETHER · PEOPLE WITH AGENTS — START · BIL-142 · THE THREAD

# billing

A  Ana · finance
refunds must be in it
constraint

R  Raj
agreed: CSV first, PDF later
decision

R  Raj
@billing-agent build it

AI  billing-agent  APP
On it. Opened BIL-142, with three questions.

sync →

BIL-142
CSV billing export

Decisions
CSV first, PDF later (Raj) · refunds in (Ana)

Plan
not yet: the agent asks first

Checks
not yet

IN SHORT  Ana brings the constraint, Raj decides the scope, and the agent is in the room. What’s decided lands on BIL-142; plan and checks come next.

Gray (Stripe) — stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents · Lai (Atlassian) — atlassian.com/blog/development/specialist-agent-orchestration-jira · Felker — x.com/donnfelker/status/2112257140262146433

### The agent asks three questions, so every agent builds to one target

Ana answers the agent’s three questions once. Ticket BIL-142 turns her answers into checks every agent can use: the CSV must include the columns finance needs, cover only the last 90 days and show refunds as negative rows.

[11:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=661s) [Three answers become checks on the ticket. The export must contain the columns finance needs, cover only the last 90 days and list refunds as negative rows.](https://assets.ai.engineer/sites/aiecode2025/sha256/60e5954e5e644e1ae8f489290f83e061d66c36a9ea0f36fda3c6fef068f73e84.webp)

The agent asks three questions, so every agent builds to one target
AGENTS TOGETHER · PEOPLE WITH AGENTS — START · BIL-142 · THE CHECKS

BIL-142
CSV billing export
from #billing · no checks yet
every agent, its own guess

the agent asks · Ana answers
for whom? → finance
which period? → last 90 days
refunds how? → negative rows

BIL-142 · checks agreed
✓ has the columns finance needs
✓ covers the last 90 days only
✓ refunds as negative rows
every agent, one target

IN SHORT  Three questions, Ana answers once. The finished ticket carries the checks: agents build to a check, not a guess.

Developer Toolkit — developertoolkit.ai/en/teams/agent-ready-backlog · Koshy — hex.tech/blog/dont-be-naked-when-the-agents-arrive · Anthropic — anthropic.com/research/employment-at-anthropic · Tools: AWS Kiro specs · GitHub Spec Kit · Tessl

## Full transcript

[0:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=0s) Welcome to our session on multiplayer

[0:02](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=2s) software factories where I'll walk you

[0:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=4s) through what the tensions are, what the

[0:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=6s) solutions are when multiple people and

[0:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=9s) multiple agents are working on the same

[0:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=11s) software delivery pipeline. Software

[0:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=14s) delivery pipelines are of course not new

[0:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=16s) and existed before uh uh AI and you know

[0:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=21s) we have the typical build test and then

[0:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=24s) kind of wait for the release and the

[0:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=26s) merge to go out into main. uh this is

[0:28](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=28s) pretty much a serial flow and it has

[0:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=31s) helped us automate and be more robust in

[0:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=34s) the delivery. At the same time, people

[0:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=36s) are building factories and I call them

[0:38](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=38s) solo factories on their laptops on their

[0:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=41s) kind of systems uh within their coding

[0:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=43s) agents and increasingly they're using

[0:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=46s) multiple agents and doing kind of

[0:48](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=48s) delivery with agents. Now they often

[0:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=52s) have to still make the decisions and

[0:53](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=53s) they also have to do the merges and they

[0:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=56s) kind of are a little bit of this central

[0:59](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=59s) piece or almost like they have to keep

[1:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=61s) the memory what they're doing and so on.

[1:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=64s) I'm talking not single player of not

[1:07](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=67s) solo player but uh multiplayer and

[1:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=69s) there's probably a gradation in between

[1:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=72s) currently people doing it on our laptops

[1:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=74s) then people sharing their setups like

[1:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=76s) their context their skills their loops

[1:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=79s) within their factories pretty much the

[1:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=81s) state of many factories out there and

[1:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=83s) then the multiplayer factories of people

[1:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=86s) collaborating at the same time uh in the

[1:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=89s) same kind of uh kind of ticket board uh

[1:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=92s) on their same code base And that's what

[1:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=94s) I'll work you through today. Now on the

[1:38](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=98s) left, the tension is everybody wants to

[1:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=101s) merge into main. On the right, there's

[1:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=103s) multiple people on the board and they

[1:45](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=105s) have to collaborate and work together.

[1:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=107s) So that's kind of the two parts of this

[1:49](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=109s) talk. Let's start with the first part,

[1:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=112s) the code, and how to make that like a

[1:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=114s) central piece of agents being able to

[1:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=116s) work together.

[1:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=118s) You know, one of the first things when

[2:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=120s) you turn on a factory or multiplayer

[2:02](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=122s) factory, you'll see that there's

[2:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=124s) definitely an increase in pull requests,

[2:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=126s) you know, it almost like a factor 10 uh

[2:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=130s) of more and more pull requests landing.

[2:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=132s) Uh that's good because we're being more

[2:15](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=135s) productive. We get more changes done and

[2:17](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=137s) but that also builds up some of the

[2:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=139s) tension.

[2:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=141s) For example, um we have a lot more

[2:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=144s) merges and they have to make sure that

[2:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=146s) they're not conflicting and if we're

[2:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=149s) unlucky, the agents also spend time of

[2:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=152s) going rounds around us. Uh you know, one

[2:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=155s) agent changing something then the other

[2:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=156s) agent changing it back. These conflicts

[2:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=159s) are real when you turn on a multiplayer

[2:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=161s) factory. And one of the most noticeable

[2:45](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=165s) things is we start to wait more for

[2:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=167s) releases because when we merge a change

[2:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=170s) all the other PRs need to rebase and

[2:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=172s) they typically rerun their tests uh and

[2:55](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=175s) you'll have to wait and at the same time

[2:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=178s) that means actually your CI/CD system is

[3:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=181s) becoming a lot lot slower because of

[3:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=184s) that multi- thing and also more costly

[3:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=186s) but that's a side effect.

[3:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=189s) Now the PRQ is kind of building up not

[3:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=192s) just with features. There's also the

[3:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=194s) agent incidents that we have to solve as

[3:17](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=197s) I mentioned and then there's factory

[3:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=199s) maintenance on their own like the

[3:20](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=200s) improvement of the skills the

[3:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=202s) improvement of the loops that we've been

[3:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=203s) using all more more and more work that

[3:28](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=208s) needs to get approved by us. So why

[3:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=211s) can't we flip this from being this

[3:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=214s) concurrency and it being an exception to

[3:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=216s) becoming the routine? And this is what I

[3:38](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=218s) call conc concurrent delivery and going

[3:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=221s) from continuous delivery to concurrent

[3:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=223s) delivery and design for people to work

[3:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=226s) and agents to work together on the same

[3:48](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=228s) codebase.

[3:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=230s) Now one of the simple things that we uh

[3:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=232s) can do is instead of just running and

[3:55](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=235s) running agents just in parallel we can

[3:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=238s) get smarter about this uh almost like

[4:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=241s) splitting up the work like we would do

[4:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=243s) with units like you get to do this task

[4:05](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=245s) you get to do that task and there's

[4:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=248s) different ways of splitting this in a

[4:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=250s) way that we can say well you work on

[4:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=251s) authentication I work on payment I work

[4:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=254s) on other parts and we can use even the

[4:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=256s) ASD graph to determine which pieces are

[4:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=259s) like able to split quite well and then

[4:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=262s) we can go have the agents go on more

[4:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=264s) granular level and they would do like

[4:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=266s) hey this file this function and even

[4:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=269s) they would go on certain keystrokes like

[4:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=271s) in certain files doing together. So this

[4:33](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=273s) is a way of kind of dealing with kind of

[4:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=276s) more uh splitting of the work before you

[4:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=279s) actually do uh the actual coding. This

[4:42](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=282s) is a better way of planning the changes.

[4:45](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=285s) And then once uh you start planning and

[4:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=287s) you start actually executing the plan uh

[4:51](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=291s) much like you would do on your uh scrum

[4:53](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=293s) board, you would say I'm going to take

[4:55](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=295s) care of this and the agent writes and

[4:57](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=297s) says it claims the ticket. It says I

[4:59](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=299s) want to do that ticket. So no other

[5:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=301s) agent can actually step in at the same

[5:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=303s) time. And it also announces which files

[5:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=306s) and which changes it's going to make. So

[5:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=309s) this is something that is helpful for

[5:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=310s) other agents to see that they're not

[5:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=312s) starting to overlap during the planning

[5:15](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=315s) and the execution.

[5:17](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=317s) Now to make sure that they can keep

[5:20](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=320s) executing um a lot of people use work

[5:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=322s) trees to kind of separate them. When you

[5:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=324s) kind of think about this broader there

[5:27](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=327s) is a lot more splitting that you could

[5:28](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=328s) do. You basically are phrasing the world

[5:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=331s) of an agent. You give them their own

[5:33](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=333s) kind of machine. You give their their

[5:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=335s) own phrase of the context. to give them

[5:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=337s) their own version of the API that's

[5:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=339s) being locked and even the database gets

[5:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=341s) their snapshot their test data and even

[5:45](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=345s) outside world like digital twins and uh

[5:48](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=348s) kind of making sure that everything's

[5:49](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=349s) mocked and that they can do these things

[5:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=352s) without having to deal with any impact

[5:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=354s) of the outside world.

[5:57](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=357s) Now when two agents do collide during

[6:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=360s) the work there's a couple of strategies

[6:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=361s) they can either start like waiting for

[6:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=363s) each other um one after the other they

[6:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=366s) can retry after the wait they can say

[6:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=369s) like okay I'm going to wait but I'll

[6:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=370s) recue and I'll wait until it's done or

[6:13](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=373s) they can start changing and optimizing

[6:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=374s) the plan like you do this I do that and

[6:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=378s) that's renegotiation uh in the end so

[6:20](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=380s) they're changing actually the planning

[6:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=383s) while they're doing the execution to

[6:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=385s) make sure that they don't interfere with

[6:27](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=387s) each other.

[6:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=389s) Now on a conflict you could rerun it. Um

[6:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=392s) and within get you're merging today and

[6:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=395s) you say okay there's a conflict. What do

[6:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=397s) I do? You rerun and see if it merges on

[6:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=401s) the rerun which was typically our PR uh

[6:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=404s) change or you could just kind of make

[6:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=406s) sure that the agents do that for you

[6:49](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=409s) instead. So they can see whether they

[6:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=412s) can merge instead of just by code lines.

[6:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=414s) they can merge by function and it

[6:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=416s) becomes smarter and then the agent maybe

[6:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=418s) can fix [clears throat] the merge so you

[7:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=420s) don't have to do that again and

[7:02](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=422s) ultimately it can even start seeing

[7:05](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=425s) changes coming so hey this agent is

[7:07](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=427s) probably going to change this I'm going

[7:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=429s) to see this coming and I'm already kind

[7:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=431s) of adapting my code uh at the same time

[7:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=434s) so this is thinking in concurrency

[7:17](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=437s) instead of being kind of serial in the

[7:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=439s) changes

[7:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=441s) now one of the things you can see is

[7:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=443s) that you agents have been optimized to

[7:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=446s) merge stuff, right? Like with the

[7:28](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=448s) merging of code, this is clear. But what

[7:30](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=450s) if two changes land at the same time? In

[7:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=454s) this case, you're calculating and

[7:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=456s) changing the function of calculating the

[7:38](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=458s) the total for an invoice and say it's

[7:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=461s) not just in dollars, but it in dollar

[7:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=463s) cents. Now, at the same time, there is

[7:45](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=465s) another PR that changes the fact of

[7:48](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=468s) reporting out. Now two mergers that

[7:51](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=471s) consistently could merge with the test

[7:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=474s) succeeding but at the same time it was a

[7:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=478s) different intent. The report don't want

[8:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=480s) to have it in euro cents or in dollar

[8:02](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=482s) cents. Right? So they're not conflicting

[8:05](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=485s) in code but they're conflicting on

[8:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=488s) intent. So we could have agents actually

[8:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=490s) look at the intent whether they're still

[8:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=492s) consistent across the multiple mergers

[8:15](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=495s) and warn us or change the PR

[8:17](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=497s) accordingly.

[8:20](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=500s) Now, if you want to kind start merging,

[8:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=503s) um the PRs are able to merge, they're

[8:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=505s) good to merge. Um but what if one of

[8:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=509s) those mages uh merges doesn't uh merge

[8:33](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=513s) well, right? Then you'll have typically

[8:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=515s) rebase all the others, they'll have to

[8:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=517s) do rework and so on. Now, there's a

[8:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=519s) better way of dealing with these merge

[8:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=521s) trains is by looking uh in a concept

[8:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=524s) called speculative merge trains. And it

[8:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=527s) looks at all the PRs coming in and it

[8:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=530s) sees which ones are compatible with each

[8:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=532s) other and it kind of already checks them

[8:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=534s) in pairs. And then it says like when

[8:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=536s) that is landing and this one isn't

[8:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=538s) landing, but you could still do the

[8:59](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=539s) others, it goes faster because all the

[9:02](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=542s) others that can go through already go

[9:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=544s) through in the merge cube.

[9:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=546s) Uh these are just some examples of kind

[9:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=549s) of new strategies of dealing with merges

[9:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=552s) and conflicts and reviews and better

[9:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=554s) planning. I think in general there's a

[9:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=556s) new kind of infra layer coming and you

[9:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=558s) see that almost from the vendors you

[9:20](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=560s) know it's a new developer infrastructure

[9:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=562s) mergers are going to be handled

[9:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=564s) differently there's now an analytics

[9:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=566s) there's now a better planning there's

[9:27](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=567s) now a better tool for anything and

[9:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=569s) that's kind of what we're building up uh

[9:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=572s) right now a lot of the factories are

[9:33](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=573s) just glorified loops as we would do with

[9:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=576s) the SCD but the concurrency will only

[9:38](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=578s) increase

[9:40](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=580s) now I told you there was a flip side to

[9:42](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=582s) this there's also the humans working

[9:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=584s) together, not just the agents. And the

[9:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=586s) typically the change is that you're

[9:48](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=588s) working together in one kind of task

[9:51](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=591s) board, right? And all the humans are

[9:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=594s) being able to see what changes are

[9:55](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=595s) coming, what tasks are being done. And

[9:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=598s) this creates the visibility where in

[10:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=600s) your solo factory, you would have that

[10:02](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=602s) doing that all alone, but it wouldn't be

[10:05](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=605s) a central kind of board that you're

[10:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=606s) working on. Now, they all need your

[10:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=609s) attention, and that's probably the easy

[10:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=611s) part, right? So we want to reduce also

[10:13](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=613s) that attention uh from the agents having

[10:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=616s) to call you all the time. So this is a

[10:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=618s) side effect of having multiple agents

[10:20](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=620s) working at the same time.

[10:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=623s) Now one of the nice features is and uh

[10:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=625s) it's been kind of interesting to see

[10:28](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=628s) that agents can join your chat and this

[10:30](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=630s) is a different way of coding. It is not

[10:33](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=633s) you prompting but it's you kind of

[10:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=636s) pulling an agent into a conversation. Uh

[10:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=639s) and that's really powerful because the

[10:40](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=640s) agent is picking up clues not just from

[10:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=643s) you from your team members at the same

[10:45](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=645s) time. And what it's actually doing it is

[10:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=647s) refining the ticket from all the input.

[10:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=650s) And that is really powerful because you

[10:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=652s) actually not only had like adversarial

[10:55](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=655s) review by agents, but you also get

[10:57](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=657s) multiple input by humans on the same

[10:59](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=659s) ticket while during the conversation.

[11:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=663s) And what it's really good at is

[11:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=666s) prompting you with questions instead of

[11:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=668s) having to ask everything over and over

[11:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=670s) again. So one thing that helpful is that

[11:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=674s) it clarifies what is the test, what

[11:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=676s) should it do, what are the requests

[11:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=679s) uh requirements that it needs to do. And

[11:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=682s) the ticket actually becomes almost like

[11:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=685s) a plan the plan mode in your coding

[11:27](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=687s) agent but now as a share feature within

[11:30](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=690s) your board um of looking at all the

[11:33](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=693s) requirements.

[11:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=695s) Now what's even more powerful is that it

[11:38](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=698s) doesn't only have to be engineers. Think

[11:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=701s) of this as in the past sales marketing

[11:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=704s) support they were kind of filing tickets

[11:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=706s) to the engineering that would get

[11:49](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=709s) somewhere on a board and they all have

[11:51](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=711s) to wait until an engineering comes that

[11:53](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=713s) could have taken weeks. Right now what

[11:55](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=715s) we see in our factory at Tesla is that

[11:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=718s) people are just sharing and doing a chat

[12:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=720s) within kind of the uh organization and

[12:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=723s) the agent is there. Now they don't need

[12:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=726s) to build um the uh uh the code all the

[12:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=731s) time and before [clears throat] they

[12:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=734s) were maybe doing vibe coding but one of

[12:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=736s) the problems with the vibe coding is it

[12:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=738s) didn't fit according to engineering

[12:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=741s) practices. Now with a multiplayer

[12:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=744s) factory people are using the same

[12:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=745s) pipeline the same knowledge the same

[12:27](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=747s) skills the same loops to actually

[12:30](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=750s) already fit into that flow of

[12:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=752s) engineering itself. So they can

[12:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=754s) experiment, they can refine the feature

[12:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=757s) and they can also even build the feature

[12:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=759s) where before we would wait they can just

[12:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=761s) kickstart it and engineering refused

[12:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=764s) that. That's a very powerful flow of

[12:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=766s) getting everybody on board and being in

[12:49](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=769s) the flow of that one multiplayer

[12:51](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=771s) factory.

[12:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=774s) Now sometimes the agent while executing

[12:57](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=777s) is unsure and you might have the same

[13:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=780s) feeling that sometimes the ticket mode

[13:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=783s) within a factory is slow and you want to

[13:05](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=785s) do fast iteration. Now there's a way to

[13:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=788s) do this hybridly when for example your

[13:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=790s) agent is is stuck. Uh there was a very

[13:13](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=793s) interesting ID from Helix ML where when

[13:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=796s) your agent is stuck is actually starts a

[13:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=799s) new kind of coding IDE with the exact

[13:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=802s) context that the agent was working on

[13:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=805s) you as a human almost jump in uh to help

[13:28](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=808s) the agent figure out like with all the

[13:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=811s) context available with all kind of the

[13:33](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=813s) files available and then when you made

[13:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=815s) the right choices when you did the right

[13:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=816s) experiments you hand it actually back to

[13:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=819s) the agent and the factory to continue.

[13:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=821s) So this is a nice way of finding the

[13:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=823s) middle ground between a personal coding

[13:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=826s) agent fast iterations and still doing

[13:48](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=828s) the factory uh and the agent can use it

[13:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=830s) as well to kind of clarify and help uh

[13:53](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=833s) and ask for help.

[13:55](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=835s) Now what we really want to do is reduce

[13:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=838s) kind of the choices uh that it has to

[14:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=841s) kind of make and what is really powerful

[14:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=844s) is that it represents actually questions

[14:07](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=847s) to us for decisions not just what should

[14:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=851s) I do and open questions you know you see

[14:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=854s) that in coding agents as well it gives

[14:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=856s) you a couple of options that you can

[14:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=858s) choose for and then it goes off this is

[14:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=861s) really powerful and it is less trained

[14:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=865s) on like having to tell the agent all the

[14:27](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=867s) time what to do by presenting options

[14:30](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=870s) there as well. Of course, you can

[14:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=872s) override, but this is really a powerful

[14:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=874s) multiplayer thing.

[14:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=877s) Now, every decision that people make

[14:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=879s) actually goes onto a ledger. This is

[14:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=881s) like your context locally maybe that you

[14:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=884s) have in your coding agent. But if you

[14:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=886s) are in a multiplayer factory, this is

[14:48](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=888s) shared somewhere on a decision log and

[14:51](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=891s) that can be used either by agents, it

[14:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=894s) could be used by humans to find and you

[14:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=896s) can trace things back like who made what

[14:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=898s) decision uh and when that context is

[15:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=901s) being used in the next session, you can

[15:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=903s) also query that as well.

[15:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=906s) Now we want that to be small because big

[15:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=908s) changes uh they are not very readable.

[15:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=911s) So while I said in the beginning you

[15:13](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=913s) could optimize for agent not being

[15:15](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=915s) conflicting. There is also another kind

[15:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=918s) of thing you have to think about which

[15:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=919s) is the human review. How much change can

[15:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=922s) a human review but you can build like

[15:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=925s) separate Pars in multiple main merge

[15:28](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=928s) trains for people to do fast reviewing

[15:30](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=930s) of those things.

[15:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=932s) Now a lot of people are focused on kind

[15:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=935s) of you know when the PR and we want to

[15:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=939s) reduce the number of PR reviews is that

[15:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=941s) there is some kind of automated review.

[15:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=944s) Now the first part is typically to

[15:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=947s) reduce the failures which is great right

[15:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=950s) like we we want to provide better

[15:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=952s) context better tools we have adversarial

[15:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=954s) agents look at the code before it comes

[15:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=956s) to us that is a good way of reducing

[16:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=960s) kind of the risk uh by it being better

[16:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=963s) quality now at the same time we're

[16:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=966s) optimizing that we can actually see what

[16:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=969s) it did we are asking for screen flow uh

[16:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=972s) shots for videos for proof for testing

[16:15](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=975s) all the things that could help a

[16:17](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=977s) reviewer and then ultimately how far do

[16:20](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=980s) you go several people tell me like hey

[16:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=983s) I'm not looking at the code anymore and

[16:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=985s) I asked them okay you know but what is

[16:28](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=988s) the impact of this going to production

[16:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=992s) some documentation

[16:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=994s) that is limited impact maybe you know

[16:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=997s) some don't have real customers which is

[16:40](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1000s) also great right like the impact is not

[16:42](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1002s) a lot but if you really start thinking

[16:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1004s) about what you're doing is you're

[16:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1006s) selecting by what risk you can take. So

[16:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1010s) some of the tests will kind of say well

[16:53](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1013s) if it's maybe in the documentation part

[16:55](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1015s) you can go ahead if it's like a a more

[16:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1018s) impact fail change like within

[17:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1021s) authentication you kind of do more kind

[17:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1024s) of review by human and sometimes there's

[17:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1026s) a middle ground hey this feature can

[17:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1028s) just roll out we'll check what the

[17:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1030s) output is whether there's any errors

[17:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1032s) like gradual releases. So instead of

[17:15](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1035s) only optimizing for quality and reducing

[17:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1038s) of the likelihood, you also kind of have

[17:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1041s) a way of looking at it from a risk

[17:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1043s) perspective. And when it moves out of

[17:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1046s) production, you know, you can also see

[17:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1049s) how you can mitigate the risk, right?

[17:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1051s) Because if the impact is that you uh

[17:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1055s) lose data, do you have a fast restore

[17:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1057s) strategy? uh or you can think about this

[17:40](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1060s) like what if one node fails or can I

[17:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1063s) fast roll back those are architectural

[17:45](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1065s) decisions as well. So what you want to

[17:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1067s) do is when things go wrong you want to

[17:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1070s) have it being cheap to restore or to fix

[17:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1074s) and that is important in not only

[17:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1076s) optimizing but there's multiple ways of

[17:59](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1079s) kind of dealing with the risk on the PR

[18:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1081s) review.

[18:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1083s) Now, one of the funny things when you

[18:05](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1085s) work in a multiplayer factory is that um

[18:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1088s) you know before people were chatting and

[18:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1091s) I personally for example work remote

[18:13](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1093s) where most of the team is in a central

[18:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1096s) place in London. Now they get together

[18:18](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1098s) they do a lot of chats and so on and me

[18:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1101s) sometimes from remote I had a hard time

[18:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1103s) catching up what has changed. Now, when

[18:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1105s) you turn on the multiplayer factory,

[18:27](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1107s) everybody needs to keep up, right?

[18:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1109s) There's so much code being produced that

[18:32](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1112s) maybe marketing support and other places

[18:35](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1115s) can't keep up. They need to have a

[18:38](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1118s) translation in their changes that have

[18:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1121s) happened in their language. So,

[18:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1123s) communication and radiating change is

[18:46](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1126s) actually a very important feature in a

[18:48](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1128s) multiplayer factory. How do you keep up

[18:51](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1131s) within your domain within your

[18:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1132s) understanding for your part of the job?

[18:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1136s) Now in a nutshell you can do a lot of

[18:59](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1139s) automation and you will use a lot of

[19:02](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1142s) skills uh and that like context and

[19:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1144s) better improvement uh on those pieces

[19:07](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1147s) and you kind of reserve the people for

[19:09](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1149s) the exceptions and that's the way that I

[19:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1152s) want you to think about is automate what

[19:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1154s) you can but make sure you are able to

[19:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1156s) route to a human to make the right

[19:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1159s) decision

[19:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1162s) with all that infrastructure with all

[19:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1164s) those kind of ways of working together.

[19:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1166s) Um there is kind of a new team that is

[19:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1169s) forming which is almost like the factory

[19:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1171s) team uh similar to a platform team that

[19:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1174s) was dealing with a kubernetes or with a

[19:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1177s) cluster or with the cloud but right now

[19:40](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1180s) this is they are dealing with the coding

[19:43](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1183s) agents and the coding fabric of working

[19:45](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1185s) all together. They make sure that who

[19:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1187s) owns the skills the context is up to

[19:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1190s) date. they make sure that things are

[19:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1192s) connected to the right pieces uh and

[19:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1194s) that the whole factory also itself is

[19:57](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1197s) being maintained uh and being monitored

[19:59](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1199s) as well.

[20:02](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1202s) So this is a nutshell. There's a lot

[20:04](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1204s) more to it, but this was in a nutshell

[20:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1206s) two things like the pressure is building

[20:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1208s) up on agents working more together in

[20:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1210s) the codebase and then the humans also

[20:14](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1214s) kind of working with the agents more and

[20:16](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1216s) more together in a concurrent way and

[20:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1219s) delivering more output at the same time.

[20:21](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1221s) And for that there needs to be a lot of

[20:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1224s) change. Now one of the things that we're

[20:26](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1226s) playing now with is they're not just the

[20:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1229s) coding agents. They're not just the

[20:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1231s) people that do things in the board. Now

[20:34](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1234s) they're being those personal agents and

[20:37](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1237s) they will work in the uh board. They

[20:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1239s) will make decisions for you. They will

[20:41](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1241s) provide answers to other agents as well.

[20:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1244s) This is a new way of building. This is a

[20:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1247s) new way of kind of delegating some of

[20:50](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1250s) the tasks that you are doing in the

[20:52](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1252s) factory.

[20:53](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1253s) So my advice is brace yourself. We're

[20:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1256s) not there yet. like the coding agent

[20:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1258s) were a good step on your solo factories.

[21:01](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1261s) Multiplayer factories will bring new

[21:03](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1263s) dynamics both to the agents coding and

[21:06](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1266s) both to the organizational working

[21:08](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1268s) together. And that's it and thank you

[21:11](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1271s) very much for listening. You can kind of

[21:13](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1273s) find the slides by asking uh to me in DM

[21:17](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1277s) on LinkedIn. I happily send you in

[21:19](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1279s) exchange for some feedback. Um and you

[21:22](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1282s) know you can of course try the Tesla

[21:24](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1284s) factory where we implement and uh are

[21:27](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1287s) working on kind of loops factories and

[21:29](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1289s) skills uh for you uh being in a

[21:33](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1293s) multiplayer mode and I'd also uh shared

[21:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1296s) the research at a site on concurrent.cd

[21:39](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1299s) where I find like people and uh tools

[21:42](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1302s) and techniques that people are solving

[21:44](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1304s) uh this concurrency all together. Thank

[21:47](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1307s) you very very much for listening and I

[21:49](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1309s) hope you learned some of the new things

[21:51](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1311s) today and feel free to leave uh some

[21:54](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1314s) comments and I'll happily have a look

[21:56](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1316s) and respond to that. Thank you very

[21:58](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1318s) much.
