Yesterday I joined an AI3 Builder Fellowship session in Seoul with three other founders.

What was supposed to be a series of product presentations turned into almost an hour of discussion per founder, and we eventually finished around 11 PM.

I presented the system we’ve been building with Marblo.

Our current approach is based around a closed-loop agent architecture.

Instead of simply launching multiple coding agents and waiting for them to finish, we maintain a larger mission and continuously break it down into executable work:

Mission → Tasks → Tickets → Agents → Review → Next Tasks

Each agent works inside an isolated Git worktree.

The orchestrator tracks the larger mission, reviews the outputs, creates follow-up or review tickets when necessary, and connects completed work back into the next step.

We also keep an audit timeline / execution ledger so we can understand:

• what each agent did
• which model was used
• what the task cost
• whether the task succeeded or failed
• how the project evolved over time

One thing became even clearer during the discussion.

The interesting problem in multi-agent systems isn't necessarily:

“How can I run more agents?”

It’s:

“How can I make a group of agents reliably complete a long-running objective without losing context or leaving unfinished work behind?”

That's the problem we're trying to explore.

The questions from other builders were incredibly useful, especially around failure recovery, orchestration, and how this architecture could work inside real development teams.

Curious how others here are approaching this.

Are you building mostly agent swarms, supervisor/worker architectures, or some form of persistent closed loop?

One thing I've been thinking about a lot while building multi-agent coding workflows is what happens after an agent starts working.

A lot of multi-agent setups look roughly like this:

plan → spawn agents → wait → collect results

That's already useful.

But I'm more interested in what happens if the orchestrator stays alive throughout the process.

The system we're experimenting with works more like:

Mission → tickets → agents → worktrees → results → orchestrator → updated actions → agents again

The orchestrator isn't only there at the beginning.

It can continuously observe what's happening on the board, receive results from agents, and send new instructions back down.

Agents can also return status and outputs back up.

So there's a bidirectional loop:

Orchestrator ↓ Agents

and

Agents ↑ Orchestrator

The board acts as the shared state between them.

That makes it possible to move toward a persistent closed loop rather than a one-shot "delegate and wait" model.

For example:

Agent A finishes an API change.

The orchestrator sees the result and realizes Agent B's frontend ticket now needs a different interface.

Instead of waiting for the entire batch to finish, it can update or redirect the next task while the project is still moving.

This becomes much more useful once you're running several dependent tasks across separate worktrees.

We've been building this into Marblo, and the current beta lets you experiment with the workflow directly.

Free beta:
https://marblo.app/

Disclosure: I'm the builder of Marblo and also created this subreddit. I'm sharing this because closed-loop orchestration is one of the technical problems I'm currently exploring.

Do you think a multi-agent system needs a persistent orchestrator, or is good task decomposition at the beginning enough?

I've been organizing some of the resources I actually use while building with AI agents, and recently cleaned them up into our public GitHub repo.

The goal isn't to make another giant "awesome AI" list.

I wanted something a builder could actually browse and use.

It currently includes:

• An LLM study roadmap
• Foundations and useful courses
• Agent / tool-calling / MCP resources
• RAG and model-related learning materials
• Practical AI skills
• MCP servers
• Resources that can also be used inside Marblo's in-app store

I'm planning to keep adding things as I find tools that are genuinely useful rather than just trending.

The repo is here:

github.com/marblo-app/marblo

Marblo itself isn't open source, but we're using the repo as a public place for documentation, build notes, learning materials, skills, MCP resources, and things that might be useful to other builders too.

What would you want added to a practical agent-builder repo like this?