01What Multi-Agent Orchestration Is
Multi-agent orchestration is how you make multiple AI agents work together in one system. In this episode, Julian Goldie shows how to connect agents like Claude, Hermes, and Anti-Gravity inside a dashboard called Agent OS. The goal is to automate tasks by having agents share memory and hand off work.
The idea sounds cool, but it is easy to mess up. Julian explains that the biggest problem is overcomplication. When you try to use many models and tools at once, things break fast.
This episode is about fixing that and building a simple system that works.
Julian answers a question from the AI Profit Boardroom. A member wanted to set up a multi-agent system for fun but could not get it working. Julian walks through the common mistakes and shows the right way to do it.
02Key Features of Agent OS for Multi-Agent Systems
Agent OS is a dashboard where multiple AI agents can work together. In this episode, Julian shows how you can run Claude, Hermes, and Anti-Gravity in one space. The system includes a shared memory feature that lets all agents read and update the same files.
- Shared memory: Agents use a common memory system, like Obsidian, to store and find information.
- Individual memory: Each agent also keeps its own built-in memory for personal context.
- AI Mastermind: A built-in feature that lets agents talk to each other when needed.
- Simple setup: The system works best when you use one instance of each agent, not multiple copies.
Julian emphasizes that the system is not for running prebuilt automations like GPTs or Gemini models. Instead, you pick one specific agent, like Codex, and use it directly. This keeps everything clean and easy to manage.
03How to Set Up Your Multi-Agent System
Getting started with multi-agent orchestration is not about building a huge system right away. Julian shows a step-by-step approach that avoids common failures. He recommends you build slowly and test each part.
- Start with one agent, like Claude, inside Agent OS.
- Connect that agent to a shared memory system like Obsidian.
- Make sure the agent works with Obsidian without errors.
- Add a second agent, like Hermes, only after the first one is stable.
- Test how the first and second agents share memory and hand off tasks.
- Add more agents, like Anti-Gravity, one at a time.
- If you need agents to talk, use the AI Mastermind feature instead of complicated automations.
Julian repeats this warning: do not try to build everything at once. Even he, who works on AI daily, sees why big systems break. Starting small saves you time and frustration.
04How to Use Your Multi-Agent System
Julian walks through examples of using a multi-agent system. Instead of having multiple GPTs and Geminis, you use one specific agent per chat. For example, you have one chat with Claude, one with Hermes using a different model, and one with Anti-Gravity.
Each agent has its own individual memory. Claude keeps its built-in memory, but it also uses the Obsidian shared memory. This way, all agents can pull from the same file list and update it.
Julian says this works smoothly because Obsidian is just a list of folders and files.
- Use one instance of each agent to avoid confusion.
- Tell agents in a prompt to use a local model instead of automating the switch.
- Keep only crucial information in shared memory, not random files.
- Let agents share memory through Obsidian, but keep individual memories separate.
If you want Codex to use a local model, just write that in the prompt. Do not set up automatic rules for model changes. After a few conversations, agents forget and start using wrong APIs or keys with no tokens.
05Tests and Comparisons in the Episode
Julian does not run a formal test, but he shares results from real use. He shows that the Agent OS memory system works well with Hermes, Claude, and Anti-Gravity. Agents can read and update the shared memory without problems.
He compares using subscriptions versus API keys. Subscriptions work better for agents inside Agent OS. API keys can run out of tokens and cause breaks.
He also compares tools: Obsidian works smoothly with all his agents, while Jupyter and Google Colab are not useful for him.
Julian says overloading memory with too much information causes issues. Keeping memory lean and only storing necessary details prevents breakdowns. His own experience shows that simple systems last longer and are easier to fix.
06Tips, Limits, and Mistakes to Avoid
Julian shares several warnings about multi-agent orchestration. The main mistake is overcomplicating things, like switching between model generations or using too many tools. He advises to simplify always.
- Do not use API keys for agents like Claude—use subscriptions instead.
- Do not run multiple instances of the same model, like three Claudes.
- Do not automate model switching because agents forget and break.
- Do not fill shared memory with random information—keep it lean.
- Do not rely on tools like Jupyter or Google Colab unless you know them.
One limit is that agents might forget instructions after a few conversations. Another is that API keys can run out of tokens. Julian says to avoid these by using simple one-agent chats with shared memory via Obsidian.
He repeats that building step by step is the safest path. Even advanced users can make mistakes if they try to create a massive system on day one.
07Who Multi-Agent Orchestration Is For
Multi-agent orchestration is for anyone who wants to automate complex tasks with AI. It is perfect for users of the AI Profit Boardroom who ask questions and get personalized tutorials. Julian created this episode to help them build better systems.
If you are new to AI agents, this approach is for you because it shows a simple way to start. If you are experienced, it reminds you to avoid common pitfalls like overcomplication.
This method matters because it saves time and reduces errors. With shared memory and one instance per agent, you can automate anything smoothly. Julian shows that even he uses this simple process in his daily AI work.
