# I Run a Fleet of AI Agents Across Three Machines. Here's What Broke.

Kyle Jaejun Lee

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/4kYl2_mqmnQ-i-run-fleet-ai-agents-across-three) · [Video](https://www.youtube.com/watch?v=4kYl2_mqmnQ)

## I Run a Fleet of AI Agents Across Three Machines. Here's What Broke.

Kyle Jaejun Lee’s agent fleet turns attention, state, approvals and machine placement into separate engineering problems—and exposes what remains unsolved between them.

Familiarity with terminal sessions, Git and AI coding agents will help; no Kubernetes experience is required.

### The first bottleneck was attention

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

A MacBook sleeps. Long-running coding jobs need somewhere that does not. Kyle Jaejun Lee’s everyday fleet spans that laptop and two headless, always-on Linux boxes, connected through one control plane. The MacBook handles heavy coding and personal projects; Linux A takes long-running coding tasks, while Linux B runs short-lived personal projects. He opens with the fleet running live: daily infrastructure across two operating systems.

Before distributing the work, though, Lee ran into a limit on one machine: his own attention. A few [tmux](https://github.com/tmux/tmux/blob/master/tmux.1) panes became four, five, then six simultaneous agent contexts. Every additional agent gave him three jobs: **scheduler**, deciding who should do what; **memory**, remembering what each agent was doing; and **reviewer**, checking the results. Six active contexts were more than he could keep in his head.

![The overload diagram shows a box labeled me containing scheduler, memory and reviewer, pointing to six context boxes.](https://ai.engineer/api/talk-essay-media/8853ef4e53241ecb3c75a809a9f4e89ab772a98225b29391f15f925af186a5d7)

One human fills three roles across multiple live contexts.

### Separate context, then persist it

[1:28](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=88s)

How can a handful of executives oversee thousands of people? They do not retain everyone’s working context. Lee applied that separation to his agents, building a hierarchy with four actual entity types: **CEO, VP, manager and worker**. Each entity is an agent with its own scoped context and approval boundary. Context flows downward in the slices needed for each task; results flow upward, and Lee reviews what reaches the top.

Lee describes his supervisory context load falling from six contexts to one. That is his account of what he has to hold in mind, rather than a measure of fleet throughput. The hierarchy reduces the context reaching the human, but each agent still has a finite context window. The next question is where its state should live when that window fills.

His answer is a workspace on disk for every entity. The layout separates common obligations, machine-specific information and the work an individual agent needs to continue:

| Location or content | Purpose |
| --- | --- |
| `shared` | Context every entity must honor |
| `machines` | Machine-bound state |
| Entity workspace | The entity’s mission and current status |
| Handoff folder | Work product passed to the next agent or session |

**The durable state lives in files.** A model’s current conversation is no longer the only place that knows what the agent is doing.

That changes how Lee handles a full context window. He finds compaction slow and dislikes leaving retention decisions to a summary, so inside **Claude** he clears the context completely. The fresh context then reads the handoff and history files the agent wrote for itself and resumes from those records. Current [Claude Code session guidance](https://claude.com/blog/using-claude-code-session-management-and-1m-context) does allow focus instructions to steer compaction, although the summary remains lossy; that does not establish what Lee’s installed version supported. His preference is to make the continuity material explicit before resetting.

A context wipe—or even a machine crash—can therefore leave the written work available for recovery. This preserves recorded state and work product; it does not keep a running process alive through a crash. With continuity moved onto disk, the next problem is whether agents remain aligned with the intended plan.

### Make approval a blocking operation

[3:23](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=203s)

Plans drift as they move through the hierarchy. Initially, Lee detected that drift by entering individual panes and inspecting the work. He replaced those visits with a **review gateway**: any layer that wants to act submits its plan and blocks. The plan is pending until he approves it; approval fires a hook that starts or resumes the work automatically. One web inbox becomes the control point.

The demonstrated cycle has three steps:

1. An agent submits a plan to the gateway.
2. Lee reviews and approves it.
3. The approval hook resumes execution.

An infrastructure team inside the fleet built the gateway itself. Agents were now building the tools used to coordinate agents, and the arrangement worked well for Lee on one machine. Scaling the workload exposed a different set of limits.

### Five failures under load

[4:08](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=248s)

**1. Orchestrators did the work themselves.** An agent assigned to coordinate a task would start implementing it instead of dispatching it to a worker. Lee responded with a CLI harness and skills that invoke those CLIs. In his implementation, dispatch became the only available path for the orchestrator. The intended division of responsibility was enforced through the available operations.

**2. Worker panes became unreadable.** As managers received more tasks, they created more worker panes inside a single tmux window. Eventually, each pane was too small to inspect. Lee reports that even `tmux capture-pane`, his programmatic way of reading a pane, stopped returning meaningful content in this arrangement. The fleet had exhausted its display space as well as his ability to observe it; he does not describe a specific pane-layout fix.

**3. Accumulated sessions exhausted memory.** Lee’s Activity Monitor view shows overlapping process lists with repeated MCP entries. He describes Claude Code and MCP processes stacking up until swap was almost full and almost no free memory remained. The failure here is session accumulation consuming the host’s resources.

![Slide titled Failure 3 out of memory with overlapping process-list screenshots showing memory figures and repeated MCP process entries.](https://ai.engineer/api/talk-essay-media/3ebaaab2ed47ca7107baf29ce75d3c49d858fde5bce92d3bc2b763d9abd99157)

Failure 3: out of memory, illustrated by crowded process lists.

**4. Git credentials crossed workspace boundaries.** The desired mapping was simple: credential A belonged to workspace A, and credential B to workspace B. Instead, credentials collided and became associated with the wrong workspaces. Lee’s fix was a clean, fully separated environment for each workspace.

**5. The laptop could disappear.** Lee reports losing in-progress jobs when his MacBook lost power or dropped off the network. Network disconnection is a deployment-specific part of that account: tmux itself is designed to preserve sessions across an SSH disconnect, so losing access is not inherently the same as losing running processes. In a more decisive failure, Lee loaded the laptop with so many workers that he later opened its lid to find it had restarted. The in-flight execution was gone.

His first response was a fleet recovery command:

```bash
overlord boot
```

The command brings the fleet back up using the state already stored in files. Recovery was possible because the work was not held solely in model contexts. But restartability could not make a laptop continuously available. Lee still needed somewhere else to run the work.

### Move execution without losing context

[6:07](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=367s)

Lee added the two always-on Linux machines, offloading long-running coding tasks to Linux A and short-lived personal projects to Linux B. That added resources and took long-running work off the laptop while retaining one control plane. It also created a new requirement: an agent on one machine needed the context produced on another.

File-backed state made the transfer possible with familiar tools:

1. Commit the context files on the source machine.
2. Push the commit through Git.
3. Connect over SSH and use `tmux send-keys` to tell the destination to pull.
4. Have the destination agent read the transferred files and continue the work.

Git carries the durable context; SSH and tmux provide the signal that prompts the other machine to retrieve it.

The first version allowed two machines to change the same directory. Conflicts followed, and supposedly shared context diverged. Lee then separated machine-specific state into per-machine directories and required pull requests for shared-state changes. The separation gives local state an explicit home, while the pull-request rule puts a review boundary around changes that affect everyone.

### Bring approvals and routing back together

[7:07](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=427s)

Distributing execution also distributed the gateway: Lee now had an inbox on every machine. That recreated the attention problem the gateway was supposed to solve. He collapsed the inboxes into one main gateway, with every machine forwarding review requests over SSH. The gateway lives on an always-on Linux box because the sole point of control cannot depend on the MacBook staying awake.

Machine selection remained another burden. While developing across the fleet, Lee went looking for a feature and could not remember which machine he had built it on. He made Discord the single routing interface, with one bot for the MacBook, one for Linux A and one for Linux B. His phone became a remote control for the fleet. That unified the place from which he issued requests, though it did not yet eliminate the need to know where work belonged.

### Let agents declare requirements

[7:53](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=473s)

The distributed fleet still leaves Lee with four open engineering problems:

- **Consistency:** keeping state coherent across machines.
- **Tool access:** abstracting tools that remain local to the Mac, including MCP servers and the browser.
- **Credential handoff:** securely moving access between instances.
- **Resource management:** deciding what should run where.

He still makes placement decisions himself. The contract he wants is for an agent to declare what it needs and let the system choose where it runs.

That suggests a boundary between agent orchestration and execution infrastructure. The logical hierarchy, orchestrator and review gate sit above compute, secrets and tools; a scheduler places the workloads underneath them. Lee identifies [Kubernetes](https://kubernetes.io/docs/concepts/scheduling-eviction/kube-scheduler/) as the foundation for that direction. Its scheduler places Pods using resource requirements and constraints, which fits the requirement-based placement he wants.

This is a proposed architecture, not a completed migration. Lee intends to put existing infrastructure underneath his orchestration manager and keep the custom work focused on **task orchestration, review flow and context management**. Kubernetes supplies useful primitives, but tool portability and secure credential handling still need engineering. In particular, [Kubernetes Secrets](https://kubernetes.io/docs/concepts/configuration/secret/) are stored unencrypted in etcd by default; encryption at rest and restricted access require configuration.

Lee’s closing assessment is that single-machine operation works for him, while the cross-machine system remains rough and under construction. The next step is to reuse established infrastructure below the agent layer while continuing to build the coordination above it. He ends by inviting other people running agent fleets to compare notes on those unresolved operational problems.

## Resources

- [Building Overlord System: Personal Agent Orchestrator](https://kr.linkedin.com/posts/jjlee-swe_personal-orchestrator-%EC%9D%B8-overlord-%EB%A5%BC-%EB%A7%8C%EB%93%A4%EA%B3%A0-%EC%82%AC%EC%9A%A9%ED%95%98%EB%A9%B0-activity-7442365227733790720-KGFV) — A bilingual account of hierarchical Claude Code orchestration using tmux, file handoffs and SSH.
- [Claude Code session management](https://claude.com/blog/using-claude-code-session-management-and-1m-context) — Anthropic explains compaction, fresh sessions, written handoffs and separate subagent contexts.
- [tmux manual](https://github.com/tmux/tmux/blob/master/tmux.1) — The project manual for terminal sessions, windows, panes, detaching and reattaching.
- [Kubernetes Scheduler](https://kubernetes.io/docs/concepts/scheduling-eviction/kube-scheduler/) — How Kubernetes assigns Pods to nodes using resource requirements, constraints, filtering and scoring.
- [Kubernetes Secrets](https://kubernetes.io/docs/concepts/configuration/secret/) — Credential delivery to workloads and the encryption and access controls needed to protect Secrets.

## Slides

### A fleet of AI agents across three machines

Kyle Jaejun Lee runs AI coding agents across three machines every day. His talk traces what broke, starting with himself.

[0:00](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=0s) [Title slide introducing what broke while running AI agents across three machines.](https://assets.ai.engineer/sites/aiecode2025/sha256/68def13ccca5e601fcad47c6f342ba1ce098c4247b826fd7c8fbc4059ad4bbf6.webp)

I run a fleet of AI agents across three machines.

Here's what broke.

AI Engineer World's Fair 2026 – online talk
Kyle Jaejun Lee

### The fleet

One control plane connects a sleeping MacBook for heavy coding and personal projects with two headless, always-on Linux machines: Linux A handles long-running coding tasks; Linux B runs short-lived side projects.

[0:07](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=7s) [A control plane connects a MacBook and two always-on Linux machines with different workloads.](https://assets.ai.engineer/sites/aiecode2025/sha256/6c695348c229a76d218596645f9f5b90a766c86bd2f334c9e5021cdcb7d8a4cb.webp)

The fleet

control plane

MacBook
heavy coding + personal projects
macOS · sleeps

Linux A
long-running coding tasks
headless · always-on

Linux B
short-lived personal side projects
headless · always-on

3 machines
2 OSes
sleeps vs always-on

### The fleet, on screen

The speaker shows his everyday agent fleet on one screen: an Overlord Gateway dashboard alongside a tmux window listing sessions and Claude Code tasks.

[0:38](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=38s) [An agent dashboard and terminal showing multiple sessions, with the speaker in a circular overlay.](https://assets.ai.engineer/sites/aiecode2025/sha256/f622264607998c7741d98319f5e9439d64a711b8749061e7fd908d65e82b69c5.webp)

The fleet, on screen

Interface text:
Overlord Gateway  Online
Dashboard  Map  Reviews
18 active  4 idle  0 blocked
Context: avg -%  |  Activity: 0 calls/5min
Context Heatmap
[illegible]  SYNCED  18 active  1 idle  4 blocked  32 teams

CONTROL TOWER (4)
[illegible]
0 panes
»» bypass permissions on (shift+tab to ...
2 alerts
[illegible]
0 panes
[illegible]
0 panes

INFRASTRUCTURE (7)
[illegible]
0 panes
»» bypass permissions on (shift+tab to c...
[illegible]
0 panes
»» bypass permissions on (shift+tab to c...
[illegible]
0 panes
Enter to confirm · [illegible]

Terminal window:
tmux
0: 1 windows
zsh*: "Jaejunui-MacBookPro.local"
ovl-ceo: 9 windows (attached)
ovl-infra: 8 windows
main-: "Jaejunui-MacBookPro.local"
vp-sysimprove!*: "* Inbox [illegible]"
overlord-dev: "* Claude Code"
ccs-dev: "Jaejunui-MacBookPro.local"
apple-note-mcp: "* Claude Code"
browser-ops: "* Claude Code"
security: "* Claude Code"
orchestrator-dev: "* Claude Code"
convo-server: 1 windows
node*: "Jaejunui-MacBookPro.local"
ovl-personal: 10 windows
zsh*: "Jaejunui-MacBookPro.local"
re-agent: "* Claude Code"
stacy-shift: "* Claude Code"
life-dashboard: "* Claude Code"
baby-care: "* Claude Code"
stock-textbook: "Jaejunui-MacBookPro.local"
tutorial: "* Claude Code"
happy: "Jaejunui-MacBookPro.local"
fabricator: "* Claude Code"
contents: "* Claude Code"
ovl-staff: 3 windows
zsh*: "Jaejunui-MacBookPro.local"
rmo: "Jaejunui-MacBookPro.local"
pmo: "* Claude Code"
ovl-work: 1 windows
0 (sort: index)
(base) [illegible]
[illegible]

### The first thing that broke

With roughly four to six live agent contexts at once, the speaker became the scheduler, memory, and reviewer: assigning work, tracking each agent, and checking their work.

[0:45](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=45s) [The slide says the first thing that broke was the speaker, not a machine.](https://assets.ai.engineer/sites/aiecode2025/sha256/eeee633022881eef11c3b17b826ed9cbf2562ecd4515d78555929ee3756cb014.webp)

The first thing that broke wasn't a machine. It was me.

### The insight

Inspired by how a few executives run a company of thousands, the speaker built an agent hierarchy: scoped context flows down, results flow up, and he reviews what reaches the top.

[1:28](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=88s) [A diagram links executives managing a large company to separate context and hierarchy.](https://assets.ai.engineer/sites/aiecode2025/sha256/20abe0244ab9b5ab1a789573a9ef46cce1ea3be90e31aeba14d7b28a72fd6307.webp)

The insight

a few execs run a company of thousands → separate context → hierarchy

### State lives in files

The speaker moves agent state out of the context window and onto disk: shared rules, per-entity workspaces, and machine-bound state each have their own place.

[2:12](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=132s) [A directory tree separates shared context, agent workspaces, and machine-bound state.](https://assets.ai.engineer/sites/aiecode2025/sha256/a4f974d966b0e7a7a2f0ba2266b1626f098a55347e85070a115ed850e48c4a81.webp)

State lives in files

~/.agents/overlord/
├── shared/                     # everyone must honor
├── workspaces/{entity}/        # each agent's desk
│   commander-intent.md · status.md · handoff/
└── machines/{host}/{team}/     # machine-bound state

### I don't compact — I reset

Instead of compacting a full context window, the speaker clears it. A fresh agent reads the handoff and history files, then continues the work.

[2:42](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=162s) [A fresh agent rereads files and continues after a reset.](https://assets.ai.engineer/sites/aiecode2025/sha256/b96c94d010dcdf5ab9c916edea8bd32e88edc5ddde69d75001b961aeb6da52be.webp)

I don't compact — I reset.

compact
× slow
× can't choose what survives
× dropped = gone

→

reset
fresh agent
↓
re-reads the files
↓
continues

### The review gateway

Any layer can submit a plan to a shared inbox, where it blocks until the speaker approves it. Approval fires a hook that starts the work.

[3:19](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=199s) [Plans from any hierarchy layer pass through a blocking approval inbox before work proceeds.](https://assets.ai.engineer/sites/aiecode2025/sha256/f06fdd3430d4d8538d20fca0e377cba1f2b840168f9f48130a20ef2cb11ccba1.webp)

The review gateway

CEO
VP
Manager
Worker

submit plan ↑
any layer can submit a plan

→ blocking approval
one web inbox

hook → work

single control point

### Then one machine wasn't enough

The agent fleet’s tooling worked on one machine until a single machine was no longer enough.

[4:01](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=241s) [Text states that one machine was no longer enough.](https://assets.ai.engineer/sites/aiecode2025/sha256/c3280202d7820c7f6cfafdbfb421be5e55f0342112718a06ba113a7634e29ac6.webp)

Then one machine wasn't enough.

### Failure 1: agents do the work instead of dispatching it

The orchestrator kept doing tasks itself, so a CLI harness and skills forced it to dispatch work to a worker.

[4:08](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=248s) [A diagram shows a CLI harness directing work from an orchestrator to a worker, alongside command and skill screenshots.](https://assets.ai.engineer/sites/aiecode2025/sha256/f7a4e43246baf3f0b8829334d4ad47a3b086def96f13bdeb162dda6921aaf93b.webp)

Failure 1 agents do the work instead of dispatching it

orchestrator layer
↺ does the work itself
=> wrong!
↓ CLI harness forces dispatch
Worker

CLI to control
sh-3.2$ overlord dispatch --help
Usage: overlord dispatch [options] <team> <message-or-file>

Dispatch a task to a team (creates a task + trace, notifies manager)

Arguments:
  team                 Target team name
  message-or-file      Task message or path to a .md file

Options:
  --priority <level>   Priority: low/normal/high/urgent (default: "normal")
  --from <sender>      Sender name (default: "ceo")
  -h, --help           display help for command

Skills to call CLIs
/overlord-ceo  Overlord CEO session - organization management, team dispatch, status monitoring. Auto-load when operating as...
/overlord-team-manager  Overlord team manager session - team operations, worker management, status reporting. Auto-load when operating a...

Interface text:
> /overlord

### Failure 2: Panes too small

As managers spawned more workers in one window, the panes became too small to read. The speaker says even tmux capture-pane could no longer extract meaningful output.

[4:30](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=270s) [A grid of crowded terminal panes illustrates the difficulty of monitoring many workers.](https://assets.ai.engineer/sites/aiecode2025/sha256/6b6a226cfcf146e3ccd6f4165a8d4cbd387774709936efd1a821a1168a717dfc.webp)

Failure 2  panes too small

Interface text:
tmux (tmux)  #1  [illegible]  #2

Pane 1:
periodically and summarize results as they land?
* Cogitated for 4m 38s

Pane 2:
haven't used in a while. They still add startup and context cost — review them with /plugin

Pane 3:
(#1, #2, #7, #9, #6) for you to review.
* Sautéed for 2m 36s

Pane 4:
* Baked for 8m 11s · 1 shell still running
Draft a remediation plan

Pane 5:
41  export default function RootLayout({
* Contemplating… (11m 26s)

Pane 6:
intent. Adds a small piece of app code (guarded off in prod).
5. Chat about this
Enter to select · Tab/Arrow keys to navigate · Esc to cancel

Pane 7:
● Running 1 shell command…
· Transfiguring… (11m 26s)

Pane 8:
2>/dev/null; echo "===== dynamic =====" && gr…
* Percolating… (11m 25s)

Pane 9:
any authenticated user with no special access.
* Cogitated for 3m 59s

Pane 10:
(ctrl+b ctrl+b (twice) to run in background)
✶ Garnishing… (11m 24s)

Pane 11:
* Verifying npm run build…

Pane 12:
(ctrl+b ctrl+b (twice) to run in background)
* Grooving… (11m 20s)

Pane 13:
es/baby-care-history/fix-invi
te/app/actions/setup.ts
· Crafting… (11m 17s)

Pane 14:
stash), commit it in isolation, untouched by other agents. Safest.
6. Chat about this
Enter to select · ↑/↓ to navigate · Esc to cancel

Pane 15:
* Enlarging touch targets…

Pane 16:
15  }
Allowed by auto mode
* Julienning… (11m 15s)

Pane 17:
● Running 1 shell command…
* Churning… (thought for 2s)

Pane 18:
and I'll scope it with branches: [main].
* Sautéed for 6m 38s
push it and open the PR

Pane 19:
$ cat /tmp/ts-strict-errors.log
✶ Bloviating… (thought for 2s)

Pane 20:
agent is unaffected. Lint/format fixes get a clean PR against main.
5. Chat about this
Enter to select · Tab[illegible]
navigate · Esc to ca[illegible]

Pane 21:
care-history/app/(main)/mo
re/page.tsx)
File must be read first
* Noodling… (11m 7s)

Pane 22:
2>/dev/null; sleep 2; ps aux | grep "next/dist/bin/next build" | grep baby-care | …
* Baking… (11m 7s)

Pane 23:
(ctrl+b ctrl+b (twice) to run in background)
✶ Dilly-dallying… (11m 4s)

Pane 24:
lery-opt-verify && npm run build 2>&1 | tail -45
* Verifying build… (11m 2s)

Pane 25:
queue module [illegible]
just these 4 [illegible]
testable, mat[illegible]
records'.
4. Chat about thi[illegible]
Enter to select · Tab[illegible]

### Failure 4: Git credentials collide

Instead of mapping one credential to each workspace, both credentials converge on workspace A. The fix was a separate environment for each workspace.

[5:08](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=308s) [A diagram contrasts separate credentials for each workspace with a collision, and recommends isolated environments.](https://assets.ai.engineer/sites/aiecode2025/sha256/802b3660ed6eb25b8a5db2827066a8dc1f028af8ba5b2ead72cc61ba8c4c9635.webp)

Failure 4  git credentials collide

expected · 1-to-1
cred A → workspace A
cred B → workspace B

reality · both collide
cred A ↘️ workspace A
cred B ↗️
workspace B (struck through)

The fix: clean, separated environment per workspace.

### Failure 5: The laptop dies

Too many workers caused the MacBook to restart, losing all in-flight work. The speaker built a boot command to bring the fleet back using state stored in files.

[5:27](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=327s) [The slide says that losing laptop power or network connectivity ends in-progress jobs.](https://assets.ai.engineer/sites/aiecode2025/sha256/ee7d4dbf819fbfebe0fc8b2ff6db6bc4f13cb605bab85c4ed65540665262b96b.webp)

Failure 5  the laptop dies

The MacBook loses power or drops off the network — and every in-progress job dies with it.

### Adding machines

After losing work in flight, the speaker decides one machine is not enough and adds more.

[6:03](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=363s) [Large text reads, “So I added machines.”](https://assets.ai.engineer/sites/aiecode2025/sha256/859ab5b108622f3f3adaa74b4238771c8acaeeb69b6051dec89a6d16d9c0ef55.webp)

So I added machines.

### The offload

The MacBook offloads long-running coding to Linux A and short-lived personal projects to Linux B. Both run headless and always on, under one control plane.

[6:08](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=368s) [A MacBook offloads long-running coding tasks to Linux A and short-lived personal projects to Linux B.](https://assets.ai.engineer/sites/aiecode2025/sha256/f81557fe5b46a99eabe8bc398ca795d75ec7e8701658c1b94a7f9d55315a3c2e.webp)

The offload

MacBook
heavy coding + personal projects

→

Linux A
long-running coding tasks
headless · always-on

Linux B
short-lived personal side projects
headless · always-on

more resources
long-running work off the laptop
one control plane

### Conflict, and the fix

Two machines changed the same context directory and diverged. The fix: separate machine-specific state into per-machine directories, and change shared files only through pull requests.

[6:43](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=403s) [Two machines diverge in a shared directory; the fix is per-machine directories and pull requests for shared changes.](https://assets.ai.engineer/sites/aiecode2025/sha256/9631b161e85989dc521138406886e8ac774f4b3ce59e933bc55fdbf461c4d85b.webp)

Conflict, and the fix

conflict
machine A    machine B
↘️    ↙️
same directory · diverged ⚠️

fix
→
per-machine directories
shared/ changes only via PR

### Collapse the gateways

Each machine sends review requests over SSH to one main gateway on an always-on Linux box. This replaces multiple inboxes and keeps the gateway available when the Mac sleeps.

[7:04](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=424s) [Three machines send review requests over SSH to one always-on Linux gateway.](https://assets.ai.engineer/sites/aiecode2025/sha256/d1badfbf27f6f8d8d4c08e75446d751c9ef95a220016e53482f12f3ed07af55a.webp)

Collapse the gateways

mac
linux A
linux B

ssh
→
review requests

MAIN gateway
always-on Linux

### I forgot which machine I'd built the feature on

After losing track of where he built a feature, the speaker made Discord a single router, with one bot per machine. His phone became a remote control for the fleet.

[7:26](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=446s) [Discord routes to separate bots for a Mac and two Linux machines, above a chat screenshot.](https://assets.ai.engineer/sites/aiecode2025/sha256/2c7a3ea107a2201fa6368a290c020f6f97961d5721d3215ab9ea0ea24132d9a8.webp)

I forgot which machine I'd built the feature on.

Discord · single router → bot · mac   bot · linux A   bot · linux B

[mac] Mac에 이미 있습니다. /tmp/claude-code-analysis/ (49MB). linux에서 필요하면 새로 clone하면 됩니다: git clone --depth 1
https://github.com/cooco119/claude-code

@ovl-mac ~/personal/ 하위에 복사해줘. 리모트가 고장났어
[mac] 복사 완료. ~/personal/claude-code (49MB)

[linux] VP 의견:
1. 기존 작업 편입 (kp link)
2. 현재: 로컬 코드만 편입 가능
3. 추가 필요: GitHub URL로 바로 편입 (kp link --repo <url>)
4. 웹에서도 /projects/new에 '기존 프로젝트 연결' 탭 추가
5. 이건 구현 난이도 낮고 즉시 가치 있음. 우선 진행 추천

2. AI 프로젝트 생성
3. 옵션2 (템플릿 먼저 + remote agent 커스텀) 추천
4. 이유: 사용자가 30초 내 동작하는 앱을 먼저 보고, 그 위에 커스텀되는 경험이 훨씬 좋음
5. 플로우: 앱 설명 입력 → Claude가 템플릿 자동 선택 → 즉시 프로비저닝 → 배포 완료 후 remote agent가 코드 수정 → 자동 재배포
6. 기술: Claude API + GitHub Actions workflow dispatch
7. 리스크: agent 코드 품질 제어 필요. 초반에는 [illegible] 안전

우선순위: link 강화 먼저 (1-2일) → AI 생성 설계 확정 (이번 주)

Interface text:
Overlord team
[PERSONAL] INTEL TEAM
intel-general
intel-log
[PUBLIC] PR TEAM
pr-general
pr-log
LOUNGE
general
ideas
lounge-voice
[KRAFTON] — COMING SOON
ARCHIVE
일반
overlord
kp
ovl speak
오래된 메시지를 보고 있어요
최근으로 이동하기

### Four open problems

The fleet still needs consistency across machines, access to Mac-bound tools, secure credential handoff, and resource management that frees the speaker from deciding what runs where.

[7:52](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=472s) [Four challenges: consistency across machines, local-only tools, credential handoff, and resource management.](https://assets.ai.engineer/sites/aiecode2025/sha256/6376885703325fd9842490d7bcf397389ce135de0c252df9f34d6256143196ef.webp)

Four open problems

consistency across machines

abstract away local-only tools
Mac-bound MCP & browser

secure credential handoff

resource management
run anywhere, stop caring where

### The convergence

An agent declares its needs, while a scheduler places it on a machine; orchestration, review and resources sit between. The speaker sees Kubernetes as answering these infrastructure questions.

[8:11](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=491s) [An agent specification flows through orchestration, resources and a scheduler to underlying machines.](https://assets.ai.engineer/sites/aiecode2025/sha256/42017b7d2b15e30674c57d428e6f3776df181707304f917bf148ea75219f3f8e.webp)

The convergence

an agent, declared with a spec
what it needs, not where

orchestrator · review gate · logical hierarchy

Compute    Secrets    Tools

scheduler

machine    machine    machine
machines hidden below

### What I'm building on top

The proposed orchestration manager sits above Kubernetes, handling tasks, review flow and context. The speaker says the cross-machine setup is still rough and under construction.

[8:34](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=514s) [An orchestration manager for tasks, review flow and context management sits above Kubernetes resources.](https://assets.ai.engineer/sites/aiecode2025/sha256/d5e28905108c91e755526e04c9cb9815e54083cd9fa37af8147b1513046ae34e.webp)

What I'm building on top

Orchestration manager
 task orchestration · review flow · context management

Kubernetes
 compute · secrets · tools

build on top
reuse what exists

If you're running agents at any scale, let's compare notes.

LinkedIn
X @kyleleee_119

## Full transcript

[0:00](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=0s) Hello, I'm Kyle. I run a fleet of AI coding agents across three machines every day, and this is the story of what broke, starting with me. This is my fleet.

[0:09](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=9s) Three machines I run every single day. The MacBook is where I do my heavy coding and my personal projects, and it sleeps because, well, it's a laptop. Then two Linux boxes, both headless and always on.

[0:22](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=22s) Linux A takes the long-running coding tasks. Linux B runs my short-lived personal side projects. Two operating systems, one control plane tying it all together. And to be clear, this isn't a demo I spun up for the talk.

[0:35](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=35s) This is what I actually use all day, every day. And here it is live, the whole thing running on one screen. Real agents, real work. This is a normal Tuesday for me.

[0:45](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=45s) So let's go back to the beginning because before any machine broke, I broke. When I started, it was just me and a terminal. A few tmux panes, a few agents, then a few more, and really fast, I'm sitting in front of four, five, six live contexts at the same time.

[1:02](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=62s) And here's what nobody warns you about. At that point, I'm not running agents anymore. I've become the scheduler, deciding who does what. I'm the memory, holding what every one of them is doing, and I'm the reviewer, checking all of it.

[1:14](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=74s) One human, three roles, six contexts. It does not scale. This. This is the mess that broke me. I just couldn't hold what six agents were doing at once. My own attention was the bottleneck.

[1:28](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=88s) So I asked myself kind of a strange question: how does a handful of executives run a company of thousands of people? They don't hold all of it in their heads.

[1:36](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=96s) They separate context. Each person only ever sees their own slice. And that was the unlock. What if my agents weren't a flat pile? What if they were an organization?

[1:46](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=106s) So that's what I built, a hierarchy: CEO, VP, manager, worker. And please hear me on this. These are real entity types in the system. It is not a cute metaphor.

[1:55](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=115s) Each one is its own agent with its own scoped context and its own approval boundary. Context flows down. Each layer only gets the slice it needs. Results flow back up, and I only review what reaches the very top.

[2:08](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=128s) So instead of holding six contexts in my head, I hold exactly one. Next problem, where does an agent's state actually live? Normally, it lives inside the model's context window, and that window fills up.

[2:20](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=140s) So I moved it out. Every entity gets its own workspace on disk. Shared context that everyone has to honor lives in shared. Machine-bound state lives under machines. And inside each workspace, the mission, the current status, and a handoff folder, the actual work product that gets passed along.

[2:38](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=158s) The state lives in files. It is not trapped inside one model. And this is the single most practical thing I learned all year. When that window fills up, the built-in move is to compact, summarize the history, make room.

[2:52](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=172s) I stopped doing it. It's slow, I can't choose what survives, and whatever it throws away is just gone. So instead, I don't compact, I reset. And by reset, I mean right inside Claude, I clear the context completely, and then it just reads back the handoff and the history files it wrote for itself and picks up exactly where

[3:12](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=192s) it left off. The context can get wiped, the machine can even crash, and the work still survives because it was never only in the model. But there was still one problem: alignment.

[3:23](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=203s) Plans flow down the hierarchy, but they drift, and I'd only catch it by walking into each pane by hand. So I built a review gateway. Any layer that wants to act submits its plan, and then it blocks.

[3:35](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=215s) It waits. Nothing runs until I approve. And the second I approve, a hook fires the work off automatically. One web inbox, one control point. I never walk into the work windows anymore.

[3:45](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=225s) Here's one full cycle. A plan comes in, I approve, the work resumes. That's the whole loop. And honestly, I didn't build this gateway by hand. An infra team inside the fleet built it.

[3:57](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=237s) Agents building the tools that run the agents. I think that's kind of the whole point. So on one machine, all of this works beautifully. And then it didn't. Then one machine wasn't enough.

[4:08](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=248s) Five things broke. Failure one, my agents kept doing the work themselves instead of dispatching it down to a worker. The orchestrator is supposed to delegate. Instead, it just rolls up its sleeves and does the task itself.

[4:21](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=261s) Wrong. So I forced its hand, a CLI harness with skills that call those CLIs, so dispatching becomes the only path it can take. Failure two, and this one's almost funny.

[4:33](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=273s) As I kept throwing more tasks at my managers, they kept spinning up more and more worker panes inside a single window until it was so crowded the panes were too small to read.

[4:44](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=284s) Even tmux capture-pane, the thing I use to read a pane programmatically, couldn't pull anything meaningful out of them anymore. I'd literally run out of room to see what my own fleet was doing.

[4:55](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=295s) Failure three, out of memory. Look at this. That's my Activity Monitor completely buried under Claude Code and MCP processes. Swap almost full. Basically, no free memory left. The sessions just stacked up until the machine couldn't breathe.

[5:09](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=309s) Failure four, Git credentials. The expectation is clean. Credential A to workspace A, credential B to workspace B, one to one. The reality, they collided, crossed over, bound to the wrong workspaces.

[5:23](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=323s) The fix was a clean, fully separated environment for each workspace. And failure five, the one that really hurt. The MacBook is a laptop, so the moment it loses power or drops off the network, every in-progress job dies with it.

[5:38](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=338s) And one time, I'd pushed so many workers onto it that the whole machine just gave out. I came back later, opened the lid, and it had already restarted itself.

[5:48](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=348s) Everything in flight, just gone. So the very first thing I did was build a boot command, one overlord boot, and the whole fleet comes straight back up because all the state was sitting in files.

[5:59](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=359s) But a machine that can just vanish on you like that, that's when I knew one machine wasn't going to cut it. Every single one of these pointed at the same answer.

[6:07](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=367s) So I added machines. Here's the split. The MacBook was carrying everything, heavy coding and my personal projects. So I offloaded it. Long-running coding tasks went to Linux A, short-lived personal projects went to Linux B, both always on.

[6:21](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=381s) More resources, the long-running work finally off the laptop, and still one control plane over all of it. But now I've got context on one machine that I need on another.

[6:31](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=391s) How do I move it? Git. I commit the context files and push. Then I poke the other machine with tmux send-keys over SSH and tell it to pull. It pulls, the agent there reads the files, and picks up exactly where the first one left off.

[6:44](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=404s) Of course, it wasn't that clean. When two machines point at the same directory and both change it, you get conflicts. The same context quietly diverged. So I separated it.

[6:53](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=413s) Per machine directories for machine-specific state, and the shared stuff only changes through a pull request. It's boring, but boring is what stops the two machines from silently disagreeing. Then the gateway came back to bite me.

[7:07](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=427s) I now had one on every machine, so I was checking multiple inboxes again, so I collapsed them. Every machine sends its review requests over SSH into one main gateway, and that main one lives on an always-on Linux box.

[7:21](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=441s) Because remember, the Mac sleeps. Your one point of control can't be a thing that falls asleep. And then my absolute favorite failure of the whole project. I was developing across all of these, bouncing back and forth, and at one point, I went looking for a feature I'd built, and I genuinely could not remember which machine I'd built

[7:39](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=459s) it on. And that's when it clicked. I need one place to route from. So Discord became my single router. One bot per machine, Mac, Linux A, Linux B. My phone is now the remote control for the entire fleet.

[7:53](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=473s) So where am I now? Honestly, with a pile of things I've not solved. Four of them, consistency across machines, abstracting away the local only tools that are still stuck on my Mac, the MCP servers, the browser, secure credential handoff between instances, and resource management.

[8:09](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=489s) I really want to stop being the one who decides what runs where. And when I lined those four up, I realized these aren't new questions at all. An agent should just declare what it needs, not where it runs.

[8:20](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=500s) Above it sits the orchestrator, the review gate, the logical hierarchy. Below it, compute, secrets, tools. A scheduler places it, and the machines just disappear underneath. These are the exact questions Kubernetes already answers.

[8:35](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=515s) So that's where I'm headed. I'm not going to reinvent compute, secrets, and tools. Kubernetes already nailed those. I'm stacking them underneath and building my orchestration manager on top, task orchestration, review flow, context management.

[8:49](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=529s) Reuse what exists, build the new part on top. And that's the honest state of it. One machine, I solved. Across machines, still rough, still building. If you're running agents at any kind of scale, I'd genuinely love to compare notes because this is the part nobody has figured out yet.

[9:05](https://www.youtube.com/watch?v=4kYl2_mqmnQ&t=545s) I'm on LinkedIn and on X. Links are in the description. Thank you so much.
