My Maestro AI is a self-hosted platform for teams of AI agents. Each agent has a defined role, durable memory, scoped tools and an auditable permission policy. Agents collaborate, delegate, and run on the model best suited to the task, from Claude and GPT to a model on your own GPU. The hub, its memory and its records are stored on hardware you control. Hosted models receive the prompt and context of each turn they handle; local models keep everything on your machine.
See how it worksGet in touchAn agent that owns a domain answers from its own records, brings in specialist workers for the parts it should not guess at, and holds any outbound action until it is approved. Every fact it cites can be traced to a note, a document or a tool result.
Everything an agent needs to hold a role over months, not minutes.
Agents remember what matters, and you can see exactly what they remember.
Documents an agent reads in full on every turn: a project plan, a client file, a household inventory. You edit them in the agent's settings, or the agent keeps them current. They are its source of truth, never summarised or trimmed.
Each agent keeps long-term memory by topic and dated session notes, stored on your machine. Memory carries across sessions, restarts and changes of model.
Every turn of every agent is kept in full, tool results included, and indexed for search. An agent can recall a conversation from weeks ago and cite it, and you can search the same archive from desktop or phone.
Findings worth sharing go into a pool every agent can read, so one agent's discovery becomes the whole team's knowledge.
Change an agent's role, its rules or its Records, and the change reaches it on its next turn, even in the middle of a session that has run for weeks.
Personalities are Markdown, memory is SQLite, uploads are ordinary files. Everything can be read, backed up and versioned with standard tools.
Long-running agents outgrow any context window. The hub manages that so the agent keeps its judgement.
When a session fills up, the agent writes a brief of what matters, then continues in a fresh session with that brief, its Records, the recent turns word for word, and search over everything older. No provider-side summary, no silent loss of detail.
Compression can run as a rehearsal: the agent writes its brief, you read it, and nothing resets until you are satisfied. Critical agents can stay in rehearsal indefinitely.
Older conversation is not crammed into every prompt. Relevant past exchanges are offered with each new message, and the agent searches the archive when it needs a specific detail.
For API and local models the hub knows each model's real context window and divides it between Records, recent conversation and recalled history, so smaller models stay coherent.
On Claude and OpenAI models, the unchanged part of each prompt is served from the provider's cache, cutting the cost of a typical follow-up turn by up to ninety percent.
The lead agent carries a complete map of the software and live facts about your installation, so it can configure providers, create agents and diagnose problems for you.
Give each domain its own agent, and let them work together.
Each agent has a name, a role, a voice, a model and its own memory and files. Run a research agent, a finance agent and a project lead side by side, each an expert in its own lane.
An agent consults a named colleague, who answers with its own expertise, memory and model. If the colleague is busy, the request waits in its queue and the answer arrives when it is ready.
For a large task an agent spawns temporary workers in parallel and picks the model for each: a frontier model for hard reasoning, a fast one for lookups, a local one for private text.
Group specialists into a team that shares a folder of working documents, coordinated by a team lead. A challenger agent can be asked to argue the other side before a conclusion stands.
Put several agents in one structured discussion of a hard question. Runs are checkpointed, so a long roundtable survives a dropped connection or a restart without redoing finished work.
When a task needs expertise no agent has, an agent can request a new specialist. You approve it, and it joins with its own role, memory and model.
Choose the model per agent or per task. Memory and tools stay identical.
Use a Claude Pro or Max subscription, a ChatGPT subscription through Codex, or API keys for Anthropic, OpenAI, Google Gemini and Perplexity. The model picker shows which models bill your subscription and which bill per token.
A built-in proxy runs local models with llama.cpp or NInfer, loads each on demand and swaps them on a single GPU. LM Studio and Ollama work too. Local turns cost nothing and never leave the machine.
Memory, Records, recall, consultations, jobs, schedules, files and the permission gate behave identically on every model, so switching models never costs a capability.
Change an agent's model or its reasoning effort from the chat header on desktop or phone. The next turn uses the new choice.
When a subscription approaches its usage limit, the hub moves the next turns to the next model down and says so in the conversation.
Agents read photos, screenshots and scanned PDFs, and create illustrations with Google or OpenAI image models. Charts, diagrams and small interactive views render directly in the conversation.
Agents do not stop when you stop typing.
Agents schedule their own follow-ups in plain language, once or on repeat: tomorrow at nine, every weekday at 8:15, every Monday. When the time comes the agent wakes with the task and reports in its chat.
Long work such as a build, a data pull or a backtest runs detached from the conversation. When it finishes, the agent is woken with the result and picks up from there.
When an agent needs a decision mid-task it asks with buttons and a text box, and waits. A question survives a closed laptop, a lost connection or a reloaded page.
Type while an agent is mid-task and it takes your message into account without starting over. Stop any agent from any device.
See which agents are busy, which tools they are calling and what each worker is doing, live, on desktop and on your phone.
A monitoring script or a bot can start a turn for a specific agent, so an alert, an email or a price move reaches the right agent without you relaying it.
Agents reach the systems you choose, with credentials the hub holds, not the agent.
Plug in any MCP server: a mailbox, a document store, an internal API. Credentials are encrypted, protected by a passphrase per service or per group, and each connector is granted to named agents only.
Optional capabilities install through a step-by-step setup that explains each step, checks your keys and sets limits before anything goes live. A Coinbase exchange module is the first.
Search through Brave, Perplexity, Serper, Tavily, a self-hosted SearXNG, or DuckDuckGo with no key at all. Pages come back as clean text, PDFs are read, and pages that need JavaScript are rendered in a headless browser.
Give a script or a bot a token scoped to exactly what it needs, such as waking one agent. Tokens work from the hub's own machine unless you allow otherwise, can expire, and are revoked in one click.
Other applications can talk to your agents through a standard chat-completions endpoint, protected by a token.
Agents can message you on Telegram, and connect to Google Workspace, GitHub and other services as skills.
Capable agents need firm boundaries. Every action passes a policy you set.
Each tool call is classified as a read, write, send, admin, destructive or money action and checked against the agent's role and your overrides before it runs. One switch halts every agent at once.
Choose which kinds of action always wait for you, such as anything destructive or anything that spends money, and approve them from a card on desktop or phone.
An agent's shell and files can run inside its own container, which sees only its workspace and the folders you grant. The hub can keep sign-in credentials outside the container entirely.
Administrator rights on the machine belong to the lead agent alone. You can grant another agent root for a set time, and every root command is logged.
Every night the hub reviews its own setup: accounts and two-factor, network exposure, file permissions, agent permissions, tokens and open services. It says what to fix and how, and also runs from a terminal when the hub is down.
Administrators and members, each with two-factor authentication. Members' agents run in containers, cannot reach other members' agents or files, and have only the permissions you grant.
One hub, reachable from your desk or your pocket.
A full desktop interface and an installable phone app, with the same agents, history, files and controls. Pages reconnect and catch up after sleep, a lost signal or a restart.
Your phone tells you when an agent finishes, asks a question or needs an approval.
Each agent has its own files area for uploads and results. Drop a document or a photo into the chat and the agent reads it.
Every turn is costed in a ledger, subscription and pay-per-token usage are labelled apart, and subscription limits are shown as they are used.
Update from the toolbar or the phone menu, choosing the stable or the experimental channel each time. The hub installs, restarts and confirms it came back.
The hub checks its own machine and lists anything missing, with the exact fix for your platform, from Docker to PDF reading.
A single Node.js service with no external database. State is SQLite and plain files, straightforward to back up and inspect.
Clone the repository, run npm install, start the service. A setup page configures providers. Runs under systemd or launchd; pairs with a private network such as Tailscale for mobile access.
Name, model and a description of the role. My Maestro AI generates the identity files, which you refine over time.
Enable skills and data connectors, and grant each to the agents that need it. Least privilege is the default.
Work with agents from desktop or mobile. They retain context across sessions, delegate, run jobs, and request decisions when policy requires one.
Supported providers and integrations
Storage is yours: conversations, memory and records live on your infrastructure. Processing depends on the model you choose. A hosted provider receives the prompt and context of every turn it handles, under its own data terms. A local model sends nothing off the machine. Each agent can be pinned to one or the other.
My Maestro AI is source-available under the PolyForm Noncommercial license. Personal, research and self-hosted non-commercial use is free. Commercial deployment, including use on behalf of clients, is available under a separate commercial license.
My Maestro AI is developed by Jeff Lunglhofer. For questions, commercial licensing, or integration requests:
My Maestro AI