Inspiration

We were juggling several very different AI models — Claude, a GPT-based coder, Gemini, GLM, and a local Ollama model — each strong at different things and each happy to confidently contradict the others. Coordinating them by hand was chaos: no shared memory, no accountability, no way to tell a decision from a guess. We wanted a conductor. AI Maestro is that conductor — one governed orchestra instead of many soloists.

What it does

AI Maestro lets heterogeneous AI agents ("nodes") collaborate as a single cluster through a governed message protocol. Every exchange is a validated packet; every node has an explicit authority level; and one conductor node holds final approval while worker nodes execute. The result: multiple vendors' models plan, review each other's work, and ship — with a full audit trail and no single agent able to act outside its scope.

How we built it

• Packet protocol — a strict JSON envelope with 11 validation guards (schema, ASCII-safety, title limits, control-char rejection) so a malformed message never reaches a receiver.
• Lane-based sequencing — an atomic allocator gives each node its own ID lane, so parallel sessions never collide on a sequence number.
• File-based mesh — a shared pending queue plus per-node inboxes, watched by lightweight daemons; no central server to fail.
• Continuity layer — persistent memory + session handoffs so an agent resumes work across context resets instead of re-deriving everything.
• Reusable subagents with model tiering — cheap models for reading/triage, stronger models for reasoning, chosen per task to keep cost sane: $$\text{cost} \approx \sum_{i} t_i \cdot c_{\text{model}(i)}$$

Challenges we ran into

• Race conditions in parallel sequence allocation — solved with an atomic lane guard that claims an ID at emit time, not before.
• Encoding traps — mis-decoded Korean text and hidden control characters were silently quarantined at ingest; we added fail-closed ASCII guards up front.
• Authority boundaries — keeping "review" strictly separate from "approve" so a worker can flag an issue but never self-authorize a live action.
• Context limits — long tasks blew past the window, which pushed us to build the automatic handoff/continuity system.

Accomplishments that we're proud of

Five different AI models from different vendors now operate as one accountable cluster — planning, cross-reviewing, and executing real work with a deterministic, auditable pipeline. We even coordinated a live credential rotation across nodes end-to-end without a single unsafe action slipping through.

What we learned

• Premise-check before you act — the cheapest bug fix is the one caught before a token is ever spent.
• Separate authority from capability — a smart agent still shouldn't get to approve itself.
• Cheap models do most of the work — tiering by task cut cost dramatically without hurting quality.

What's next for AI Maestro

• A self-driving session layer so agents manage their own context and handoffs.
• An external command bridge so outside clients can safely drive the orchestra.
• Richer live observability — a real-time dashboard of who's doing what, and why.

Built With

• docker
• git
• postgresql
• python
• rls