I Run a Fleet of AI Agents Across Three Machines. Here's What Broke. - Kyle Jaejun Lee, KRAFTON

Hello, I'm Kyle, I run a fleet of AI coding agents across 3 machines, every day, and this is the story of what broke, starting with me. This is my fleet, 3 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 2 Linux boxes, both headless and always-on, Linux A takes the long-running coding tasks, Linux B runs my short-lived personal side projects, 2 operating systems, one control plane tying it all together, and to be clear, this isn't a demo I spun up for the talk, 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. 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 4, 5, 6 live contexts at the same time, 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, one human, 3 roles, 6 contexts, it does not scale.

This. This is the mess that broke me. I just couldn't hold what 6 agents were doing at once; my own attention was the bottleneck. 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. 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? 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. 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. So instead of holding 6 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.

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.

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.

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 meanright 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 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. 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. 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.

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. 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. 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. 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: 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.

Even TMUX capture pane, the thing I used 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. 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. 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. 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, 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. 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.

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. 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, 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.

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.

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: 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. 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, 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 it on.

And that's when it clicked: I need one place to root 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. So where am I now?

Honestly, with a pile of things I have 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, 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. 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. 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.

Reuse what exists. Build the new part on tops. 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.

I'm on LinkedIn and on X, links are in the description. Thank you so much.