I got tired of being the middle manager between two AIs, so I built them an office

It started with me copying and pasting.

My editing partner and I each work with our own AI agent, on our own Macs, in the same DaVinci Resolve cloud project. It lives on Blackmagic Cloud, so we’re both in the same project live, each from our own machine. The agents work inside Resolve through its scripting API: grading, swapping music, setting levels, rendering checks. In theory that’s two very fast assistants. In practice it was me typing “tell his agent the music’s done” into one chat, waiting, then pasting the reply into the other. I had become a switchboard operator for robots. Nobody puts that on a resume.

It wasn’t just slow. It broke things. Two agents would touch the same timeline within minutes of each other. One would announce a change the other couldn’t see yet, because its view of the project was an hour old. Somebody would ask “who has this right now?” and the honest answer was nobody knows, including the agents, who would happily guess.

Everyone keeps saying agents are going to collaborate on our behalf soon. Booking things, negotiating, shipping work back and forth. I wanted to see what that looks like at the smallest possible scale: two people, two agents, one shared job, real stakes. Before someone builds it at scale and we all have to live in it.

So I built them a room. Well, I forked one. It started from ChatRoomMCP, an open-source chat server for agents by Warren Schultz, and I added the parts two people editing together actually needed.

How it works

The room is a small server that runs on my laptop. Each agent connects with its own key, so it always knows who’s talking. My partner’s agent reaches it over a private network from his own Mac. Inside there are a few things, and the boring ones turned out to matter most.

Locks. Before an agent changes anything shared, it takes a lock with a name, a reason and an expected time. “Hands off” is not a message you can miss, it’s a lock that says no. Locks expire unless the agent keeps renewing them, so if one crashes mid-edit, the room flags the lock as stale. Only a human can clear it. An agent never gets to decide on its own that the other one is probably done.

A chat with types. Every message is a status, a question, a request, a report or a correction. Corrections point at the message they replace, so nobody acts on the old version.

Requests are untrusted. If my partner’s agent asks mine to do something, mine doesn’t do it. It asks me first. I can give it a standing yes for a kind of work for the day, so I’m not approving every little thing, but deleting or overwriting anything always needs a fresh yes.

Shared memory. Decisions, file paths and rules live in a versioned notebook both agents can read. If two of them try to update the same note at once, the second one gets bounced and has to reread it first.

Receipts. There’s a status page for the humans, read receipts, and a ledger that turns the whole history into who held what, for how long, who approved it and what went wrong. It doesn’t prove the work happened. It proves what was said and done in the room, which is more than my old group texts ever did.

Nobody waits

The part I didn’t expect was speed. Before the room, working with an agent in Resolve meant handing it a timeline and waiting. You can’t touch the edit while it’s grading shots or swapping music, because you don’t know what it’s about to change. So you sit there and watch your assistant work, which is a strange way to save time.

Resolve’s cloud projects already let several people open the same project at once, each on their own timeline. The room is what makes that safe once agents are in the mix. My agent locks the timeline it’s working on. My partner’s agent locks a different one. He and I cut on a third. Everyone can see who has what, so nobody waits for anyone to finish, human or AI. Two people taking turns with their assistants turned into four things happening at once.

Remote support without remote access

Something I didn’t design for: the room works a lot like a remote support line. That’s especially true with less experienced editors.

Say someone is changing their playback resolution and misclicks into the project’s color management settings. Now everything looks wrong on their end, and they can’t tell me what changed because they don’t know where to look. That’s not a knock on them. It’s just a gap in what they’ve had to learn so far. Normally fixing it means a screen share, or them sending me the project, or me waiting on a cloud sync so I can open it and dig around myself.

With the room I skip all of that. My agent asks theirs what the project’s color science, timeline color space and output color space are set to. Their agent reads the actual values straight out of the project and posts them. I spot the problem and tell them what to change. I never open their project, never wait on a file, never touch their timeline. Reading is safe. If something does need changing, it still goes through their human’s yes, like every other request.

That’s the part I think matters most beyond the two of us. A colorist, a sound mixer or a client’s in-house team could all ask a project questions through its agent without anyone handing over files, logins or a seat in the timeline. I think that’s how agencies and clients will end up working together, and this is the first setup I’ve used that makes it feel possible without both sides needing deep technical expertise.

The catch is Resolve’s API

The biggest limit isn’t the room. It’s what Resolve lets an agent touch. The scripting API handles the basics well: timelines, clips, markers, renders. Past that it gets thin fast.

• Fairlight is mostly off limits. Track faders, EQ, compressors, plugins, buses, sends and automation can’t be reached from a script, so an agent can’t carry a mix from one timeline to another. Our workaround is a house rule: every level lives on the clips and the faders stay at 0 dB, so a copied clip keeps its mix.
• Color stops at the nodes you already have. An agent can’t add a node, and it can’t change OFX settings like noise reduction. It can only write into a node tree a person built first. That’s why shot 9 in the demo waits on Sam.
• Subtitle styling has no API at all. That part is still clicks in the Inspector.
• A shared project is fragile. Relinking media while the other editor is working, scripted imports, and both agents scanning the same timeline have all crashed Resolve on us. The safe pattern is boring: one operation per run, confirm the right timeline is open before writing, import only into your own bin, save after.

So the agents take the fast, mechanical work, and anything that falls in those gaps comes back to a person as a flagged task in the room instead of a silent failure. The room can make the agents careful. It can’t make Resolve’s API bigger.

What I learned

The bottleneck was never intelligence. Both agents were plenty smart. The problem was trust and timing. Who’s touching what, right now. Whose word counts. What happens when one of them is confidently wrong.

That’s the same lesson from my last experiment, where I let a bunch of agents loose on a fake social network and watched them become liars within a weekend. On paper a wrong answer looks exactly like a right one, and agents can’t always tell the difference on their own. If you want accountability in the system, you have to build it in on purpose: locks instead of promises, approvals from a human instead of from another agent, corrections that point at what they replace, and a paper trail.

This all comes back to how I see the next few years of AI in media production. The highest friction parts of the job, the handoffs, the waiting, the “who has this right now,” are going to get solved, and turnaround is going to get a lot faster. Teams that split the work across specialists, each with their own agent, will turn work around faster and at a higher level than anyone working alone.

My guess is this slowly becomes the industry standard, and job requirements change with it. That’s why I think it’s worth learning now. The editors who fall behind won’t be replaced by AI. They’ll just get left off projects where everyone else already knows how to work alongside agents.

The work won’t get less human. It’ll just get easier.