Agent Maestro is a desktop application (Electron, macOS / Windows) for visually composing AI agent teams. Draw a hierarchy of agents, assign each one a role, a mission, documents and its own LLM — then watch them delegate, loop until reviewed, and wake up on their own. Everything runs local-first on your machine: no account, no cloud, no telemetry. Compatible with Ollama, LM Studio, OpenRouter, OpenAI, Mistral, Groq, and any OpenAI-compatible endpoint.
English · Version française · Changelog
Three releases since the first public one, driven by using the app for real:
- 📐 The Architect — a built-in agent that designs your team from a conversation. Hand it a specification or a manual and it builds from that document, then passes it on to the agents that need it. (1.9 → 1.11)
- 🗂️ Workspaces — several sealed universes, each with its own agents, documents, memories and routines, switched from a visual bar. (1.9)
- ❓ Contextual help — an (i) on every tab and field, in the interface language, hideable once you know your way around. (1.9)
- ⌨️ Copy and paste fixed — the app shipped without an application menu, so macOS never bound ⌘C / ⌘V. It now has a full bilingual menu and a right-click menu in text fields. (1.9)
- 📎 Documents up to 2M characters, replaceable in place; unlimited mission and guidelines with a full-screen editor; an eye toggle on API keys. (1.9 → 1.10)
Full history in the changelog.
Chat with one model and you get one opinion. Real work needs a researcher, a writer and a reviewer who disagree with each other — and someone to conduct them.
Agent Maestro is a desktop studio where you draw that team, give each agent a role and a model, and let them work: delegating, looping until a reviewer approves, reading the documents you attached, remembering what matters, and waking up on their own when you are not there.
Everything runs on your machine. No account, no cloud service of ours, no telemetry — just your own LLM engines.
Each node is an agent: role, mission, guidelines, temperature. Drag a link from the bottom of one node to the top of another and the first becomes the supervisor of the second — it can then delegate sub-tasks to it, recursively, and synthesise the answers.
You do not have to draw anything to start. Tell the built-in Architect what the team has to achieve and it proposes a full structure — agents with their roles, missions and guidelines, the hierarchy between them, and the loops that keep them honest. Review the proposal, apply it in one click, and the canvas fills up.
It works just as well on a team that already exists: ask for a reviewer, tighten someone's guidelines, add a whole branch. The Architect amends what is there instead of starting over, and says which mode it is in before you apply anything.
You can hand it documents too. Drop a specification, a manual, a procedure or meeting notes into its Documents tab and it designs from the real text instead of from what you managed to summarise — reusing the vocabulary, the constraints and the steps it finds there. A short or pinned document is read in full; a long one is searched by keyword against your request, so a big PDF never floods its context window, and any truncation is stated rather than silent. These documents belong to the workspace, like everything else there.
And it can pass those documents on. When it judges an agent genuinely needs one to do its job, the plan hands it over: the document is copied into that agent's own base — pinned if the Architect thinks it should stay permanently in context — so the team starts work already equipped. The plan card shows which agent receives what before you apply anything, and a document the Architect names but cannot find is reported rather than silently dropped.
It is a built-in agent, not editable — its own guidelines ship with the app. You only choose which engine it runs on, and a powerful model is strongly recommended here: designing a coherent hierarchy takes more reasoning than carrying out a single task.
A workspace is a complete universe: its own agents, loops, documents, memories, skills, routines and journal. A smart-home workspace and a property-research workspace share nothing — no crossed memories, no stray document. Only your LLM providers are shared, so you declare them once.
The bar under the toolbar shows them side by side, each with its colour, icon and content, so one
glance tells you where you are and one click changes world. ⇧⌘E creates one; the command palette
switches between them.
Declare as many providers as you like: a local engine (Ollama, LM Studio), a self-hosted gateway, or a remote service (OpenRouter, OpenAI, Mistral, Groq…). Any OpenAI-compatible endpoint works. Test the connection and the model list is fetched for you.
Then each agent picks its own engine — a small local model can draft while a stronger one reviews, inside the same loop.
A loop is a node of its own, wired to the agents taking part in it. Five kinds:
| Kind | How it works | |
|---|---|---|
| ♻️ | Producer ↔ Reviewer | One produces, another reviews, the first revises — until approved. |
| 🎯 | Until goal reached | The worker works (and delegates); a judge decides each round whether the goal is truly met. |
| 📋 | Over a list | Processes N items (parallelism configurable), list given or generated, then a synthesis. |
| 🛰️ | Permanently autonomous | Wakes up on its own, acts if needed, otherwise answers "NOTHING TO DO" and goes back to sleep. |
| 🧬 | Self-improvement | The agent re-reads its journal, memory and skills, writes new skills and better guidelines — a reviewer approves before anything is applied. |
Every loop is bounded: max iterations, token budget, max duration, plus a Stop button that is always live and a global emergency stop. You watch each iteration, each verdict and each score in real time.
Drop pdf, docx, txt, md, csv, json, yaml onto an agent. The text is extracted and indexed locally — no embedding service, no upload. The agent searches passages by keyword when it answers, or reads a whole document when it needs to. Pin a short one and it stays in its context permanently. A test button shows exactly what the agent would retrieve.
Send a mission to the conductor and follow the delegations, memory writes and skills created live, then read the synthesis.
Every delegation, verdict, memory write, document lookup and loop step is journalled.
⌘K opens the command palette — create an agent, start a loop, switch workspace, call the
Architect, stop everything. ⌘N agent, ⇧⌘N loop, ⇧⌘A Architect, ⇧⌘E new workspace,
⌘L auto-arrange, ⌘B full screen.
Closing the window moves the app to the background: loops and routines keep running, a menu-bar icon shows how many are active, and the machine is kept awake while work is pending. Optionally launches at login, hidden.
Every tab, every field that deserves it carries a small (i). Click it and you get a plain explanation of what that thing does — in the interface language, French or English. Once you know the app by heart, one switch in the settings (or the Help menu) hides them all.
Each agent owns a MEMORY.md it writes to by itself, plus a shared USER.md. After a successful
task it can save a skill — a Markdown playbook, versioned automatically — and reuse it later.
Cron-scheduled missions handed to an agent or to a loop: morning brief, hourly watch, weekly report — with system notifications.
One switch in Settings → General changes the interface and the language the agents answer
in — general rules, tool descriptions, loop prompts and verdict formats all follow. Verdict
parsing stays bilingual, so a model answering VALIDE or VALID is understood either way.
- Node.js 20 or newer (LTS recommended)
- At least one reachable OpenAI-compatible engine — Ollama or LM Studio locally, a self-hosted gateway, or a remote API
git clone https://github.com/p3x2007-ops/agent-maestro.git
cd agent-maestro
npm install
npm startThen open Settings → LLM providers, add an engine, hit Test — and start from one of the built-in team templates.
npm test # 10 suites: engine, loops, documents, multi-LLM, i18n, background,
# workspaces, architect, help & menus, metadatamacOS — npm run dist:mac → release/Agent Maestro-1.11.0.dmg. The app is not signed with an
Apple developer account, so on first launch: right-click → Open.
Windows — npm run dist:win on a Windows machine, or use the bundled GitHub Actions workflow
(Actions → Build executables → Run workflow) which produces both the .dmg and the .exe.
- macOS:
~/Library/Application Support/agent-maestro/maestro/ - Windows:
%APPDATA%/agent-maestro/maestro/
maestro/
├── settings.json # language, background mode, engine limits, active workspace
├── providers.json # LLM providers (URL, key, detected models) — shared
├── USER.md # shared global context
├── espaces.json # the list of workspaces
└── espaces/<workspaceId>/
├── team.json # agents, loops, links and positions
├── routines.json # scheduled tasks
├── journal.jsonl # full activity journal
└── agents/<id>/ # plus __architecte__/ for the Architect's own documents
├── SOUL.md # generated identity
├── MEMORY.md # the agent's persistent memory
├── skills/*.md # versioned Markdown skills
└── docs/ # attached documents (originals + extracted text)
The folder tree is created on first launch, and Settings → General shows you where it is with a button to open it. Data from a version before workspaces is moved into the first workspace automatically, without losing anything.
None of this is in the repository: your keys, documents and memories stay on your machine.
- Loops and routines run as long as the app is alive, window open or not.
- API keys are stored in clear text in
providers.json— do not share that file. - A remote provider receives whatever your agents send it, document excerpts included. To stay within your own perimeter, prefer a local engine or a self-hosted gateway.
- The engine uses OpenAI function calling, with an automatic fallback to a text protocol for
gateways that do not support
tools. - There is no length limit on an agent's mission or guidelines — write a full page if the task deserves it, and use the ⤢ button to edit it full screen.
- A document is indexed up to 2 million characters (~1000 pages). Any document can be removed or replaced by another file at any time, keeping its name and its pinned status.
- Screenshots above show the app with a sample team;
equipe-exemple.jsongets you a similar one through the Import button.
Borrows the concepts of Hermes Agent (Nous
Research) — SOUL, MEMORY.md, Markdown skills, cron — and adds the visual canvas, the agent
hierarchy, the loops and the per-agent document base.
Built with Electron, React and React Flow.
Agent Maestro — Copyright © 2026 Jean-Michel Saint-Supery. All Rights Reserved.
This software is proprietary. No part of this software may be reproduced, distributed, or used without the prior written permission of the copyright holder — see LICENSE for the full terms. Questions and licensing inquiries: please open an issue.