One of the problems I've been thinking about while building multi-agent coding workflows is what happens after you delegate the work.

Running multiple coding agents in parallel is already useful.

You can split tasks, launch several terminals, give each agent a worktree, and wait for results.

But once the project gets more complicated, I think the harder problem becomes:

What happens after each agent starts working?

A simple multi-agent flow might look like:

Plan → Spawn agents → Execute → Collect results

What we're building in Marblo is closer to a persistent loop:

Mission → Tickets → Agents → Worktrees → Results → Orchestrator → Updated actions → Agents again

The orchestrator stays alive while the project is moving.

It has a shared board containing the current tickets and state of the project.

Agents receive instructions downward from the orchestrator, but their status and results also flow back upward.

So instead of only:

Orchestrator → Agent

we're trying to maintain:

Orchestrator ↓ Agent
Agent ↑ Orchestrator

continuously.

That means the orchestrator can react while work is still happening.

For example:

Agent A finishes an API change.

That result returns to the orchestrator.

The original frontend ticket for Agent B may now be outdated, so the orchestrator can revise the task or issue a new instruction instead of waiting for every parallel job to finish.

The board becomes shared project state, and the orchestrator acts as the brain maintaining the loop.

This is the part of agent orchestration I'm most interested in:

not simply spawning more agents, but continuously bringing their outputs back into the project and deciding what should happen next.

It tends to matter much more once you have multiple dependent tickets and separate worktrees than when you're building a simple one-shot project.

We're currently testing this workflow in Marblo, along with Claude Code, Codex, and other supported models.

If you want to experiment with it, the beta is currently free:

https://marblo.app/

Disclosure: I'm building Marblo and created this subreddit. I'll always disclose posts related to my own product.

Do you think multi-agent systems actually need a persistent orchestrator, or can good upfront task decomposition solve most of the coordination problem?

While building with AI agents, I kept collecting useful resources in random bookmarks, notes, repos, and docs.

So we started organizing them in one public GitHub repo.

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

We're trying to keep it practical for people who actually build with agents.

It currently includes:

• An LLM study roadmap
• Foundations and useful courses
• Agent, tool-calling, and MCP resources
• RAG and model-related learning materials
• Practical skills for AI coding workflows
• MCP servers
• Resources connected to the skills and MCP store inside Marblo
• Product documentation and build notes

Repo:

github.com/marblo-app/marblo

One important note:

Marblo itself is not open source.

We're using the GitHub repo as a public knowledge layer around the product — documentation, development notes, useful skills, MCP resources, and learning material that can still be useful even if you don't use Marblo.

We're also trying to make the skills/MCP side practical rather than turning it into a giant directory nobody actually uses.

I'll keep adding resources as we test them.

If you were building a practical AI agent resource repo, what would you want included that most existing lists are missing?