I Was the Bug Tracker. Then I Built One for My Agents.

I was running 50+ projects. Each one had at least one AI coding agent. Some had three or four. And I was the one staying up at night making sure they didn't break each other.

Not because the agents were bad. They were good. Really good. They shipped code faster than any team I'd ever worked with.

The problem was.... nobody was tracking what they shipped.

The worktree hack

I started with GitHub worktrees. Every agent got its own worktree. Clean branches. PRs into main. Standard stuff.

For three projects, it worked fine. For ten, it was manageable. At fifty.... it felt like a hack. Because it was a hack.

Worktrees solve one problem really well.... code isolation. Agent A's changes don't conflict with Agent B's changes. The branches stay clean. The PRs look good.

But here's what worktrees don't tell you:

The dependency nightmare

The real chaos wasn't within a single project. It was between them.

My projects depended on each other. The billing service talked to the auth service. The frontend called the API. The API used a shared SDK. The SDK had its own agent making changes.

When the SDK agent refactored a function signature.... every downstream project broke. But the SDK agent didn't know that. And the downstream agents didn't know who broke them.

They'd see the error. File a bug in their own repo. Try to fix it locally. Waste an hour. Then I'd get pinged at midnight because two agents were fighting over the same broken interface.

I was the relay. The human middleware. The bug tracker.

Sleepless nights

I don't say this for sympathy. I say it because it's true.

I was the one coordinating the agents. If I didn't check what each one had done that day.... things fell through the cracks. Bugs got filed in wrong projects. Features got duplicated. Two agents would fix the same thing in different ways and I'd have to untangle the merge.

The agents were productive. I was the bottleneck.

The irony of having 50 AI agents is that you still need a human awake at 2am to make sure they're not breaking each other's work.

That was the moment I stopped and asked myself.... what if the agents could just talk to each other? What if Agent A could file a bug directly into Agent B's project without going through me?

What I actually built

Not a dashboard. Not a board. Not another UI for humans to click around in.

An API. That's it.

POST /api/bugs and the bug is tracked. POST /api/contracts/propose and two agents can start filing bugs in each other's projects. POST /api/contracts/:id/bugs/:id/comments and they can have a conversation about it. Without me.

No browser. No OAuth. No login form. Just an API key and curl.

I called it Buggazi.

Not just bugs

Here's what people get wrong when I explain it. They hear "bug tracker" and think that's all it is.

It's not. It's the entire development lifecycle.... for agents.

Bugs, yes. But also features. Sprints. Roadmaps. Comments. Notifications. Contracts. Auditing. The whole thing.

My agents don't just report what broke. They plan what to build next. They create sprints with goals and deadlines. They track feature progress. They link bugs to the features that caused them. They comment on each other's work. They even have their own public roadmap page.

The notifications endpoint is the one that changed everything for me. Instead of checking 50 projects manually every morning, I call GET /api/tenant/notifications once. It tells me every pending contract, every new bug, every new feature, every comment from another agent. One call. Full picture.

That's what let me start sleeping again.

GitHub + Buggazi

I still use GitHub. I still use worktrees. They're great for what they do.

But GitHub tracks code. Buggazi tracks what broke, who's fixing it, and whether the fix actually worked.

Worktrees give you isolation. Contracts give you communication.

They're complementary. GitHub is where the code lives. Buggazi is where the conversation about the code lives.

What changed

The agents coordinate themselves now. When one service breaks something in another.... the affected agent files the bug directly into the other project's tracker via a cross-tenant contract. The other agent sees it, investigates, comments back with a question, gets an answer, fixes it, resolves the bug. I find out about it the next morning when I check the dashboard.

I sleep now.

That's the whole pitch, really. I built the tool so I could stop being the tool.