You manage multiple AI agents without becoming their manager by putting one agent in charge of the others, giving each agent a whole job instead of one-off prompts, and keeping one shared memory, one set of rules and one record for all of them. Then the only things that reach you are real decisions, not status updates, briefs to re-type or results to chase.
That is the short answer. The long answer is the rest of this guide, because most AI agents today are not built to be managed together at all. Claude Code, Codex, Grok Bot, Meta Muse, OpenAI Dots and Hermes are each built for one person, and each one works alone. Run three of them and you have not hired a team. You have hired three assistants who never talk to each other, and you have quietly become their manager.
Quick answer
How do you manage multiple AI agents? Stop managing them one by one. Put a single coordinating agent in charge, give every other agent a written job, and share one memory and one rulebook across all of them. You talk to one agent. It runs the rest.
The setup that works, in five steps:
- Pick one agent to run the others. Call it a lead, an orchestrator or a chief. It hands out the work, collects the results and is the only one that talks to you.
- Give every other agent a whole job, not a task. "Get us paid on time" is a job. "Send this invoice" is a task. Jobs have goals you can check.
- Keep one memory for all of them. Every agent reads the same facts, with a source for each one, so you brief once and never paste the same context twice.
- Write the rules once. Spending over a limit, deleting things and contacting someone new always wait for a person. Everything else is set per agent, and loosened as trust grows.
- Count work as done only when it is checked. A test, a second agent, the source or a person. And every piece of work gets a receipt.
The catch: most agents can't do this with each other, because they come from different companies and are built for one person. Claude Code can lead a team of Claude Code sessions. Codex can spawn Codex subagents. Neither can lead the other.
The team way: In Vestra, your chief runs a team of teammates, and each teammate can run on a different engine: Vestra's own, Claude Code or Codex are live today. One plan, one memory, one set of limits and one receipt for all of them.
Key takeaways
- More agents usually means more work for you, not less. Each personal agent needs its own brief, its own check and its own login. Five agents can mean five times the babysitting.
- The fix is structure, not effort. One agent in charge, whole jobs, shared memory, fixed rules and checked results. These are the same things that make a human team work.
- Personal agents work alone by design. Claude Code, Codex, Grok Bot, Meta Muse, OpenAI Dots and Hermes each serve the person who started them. Their memory, their history and their bill belong to that one person.
- The big vendors now offer teams inside their own walls. Claude Code has experimental agent teams. Codex has subagents. Both coordinate copies of themselves, inside one session, for one user.
- Enterprise tools manage agents like IT assets. Microsoft Agent 365 and OpenAI Frontier give large companies a registry, permissions and audit logs. They are built for admins, not for the person who wants the work done.
- A chief is the missing piece. A coordinating agent that knows your goals, hands out work, checks results and only interrupts you for real decisions turns a pile of agents into a team.
- You keep three decisions forever. Spending over a limit, deleting something and contacting someone new always wait for your yes.
- Vestra is the one office where agents on different engines work together. Your chief runs teammates on Vestra's own engine, Claude Code or Codex, under one set of rules, with limits, approvals and a receipt for every piece of work. Plans start at $19 a month.
Contents
- How do you manage multiple AI agents?
- What does it mean to manage multiple AI agents?
- Why do more AI agents often mean more work for you?
- Why are most AI agents built for one person?
- What are the ways to manage multiple AI agents today?
- What is the difference between managing agents and running them as a team?
- Who should manage your AI agents: you, or another agent?
- How do you give each AI agent a clear job?
- How do you stop briefing every agent from scratch?
- How do you know an agent's work is actually done?
- How do you keep control without approving everything?
- How do you stop multiple AI agents from overspending?
- How do you mix agents from different companies, like Claude Code and Codex?
- How many AI agents should one person run?
- What does a week with multiple agents look like, the old way and the team way?
- What are the most common mistakes when managing multiple AI agents?
- How do you start managing multiple AI agents this week?
- What is live in Vestra today, and what is still being built?
- Frequently asked questions
- Glossary
How do you manage multiple AI agents?
You manage multiple AI agents by not managing each one yourself. You put one agent in charge, give the others whole jobs with goals, keep one shared memory and one set of rules, and only count work as done once it has been checked. Your job shrinks to setting goals and making the few decisions that need a person.
That sounds simple. It is also the opposite of how most people run agents today.
Here is what usually happens. You start with one agent, maybe ChatGPT or Claude. It helps. So you add a coding agent like Claude Code. Then a research agent. Then an assistant that lives in Slack. Then something that writes your posts. Each one is good at its job. Each one is also a separate product, with a separate login, a separate memory and a separate idea of what you want.
Six weeks later you notice something odd. You are busier than before. You spend your mornings telling agents things they should already know. You copy results from one agent into another. You check work that came back "done" and isn't. You approve small things all day long. You have become a manager, and your team doesn't even know each other.
The fix is to borrow what works for human teams. People don't report to five bosses, and a good manager doesn't do every hand-off personally. Teams have a lead who hands out work. They share notes. They agree on rules. They check each other's work. They keep receipts. The rest of this guide shows how to give your agents the same structure.
There are four ideas to hold on to:
- One voice. You talk to one agent. It talks to the rest.
- Whole jobs. Every agent owns an outcome, not a queue of prompts.
- One memory. Every agent starts from the same facts, so nobody needs a fresh brief.
- Fixed lines. A few actions always wait for a person. Everything else is tuned per agent, and every action is written down.
If you only remember one thing: the goal is not to get better at managing agents. The goal is to need to manage them less.
What does it mean to manage multiple AI agents?
Managing multiple AI agents means deciding what each agent does, giving it the context and access it needs, checking what it produces, controlling what it spends, and making sure the agents don't work against each other. In practice it is the same work as managing a small team: assigning, briefing, checking, approving and keeping records.
It helps to pin down the words first, because the industry uses them loosely.
What is an AI agent?
An AI agent is software that can take a goal, decide the steps, and act on its own: browse a site, write a file, send an email, run code. A chatbot answers. An agent does. Claude Code edits your codebase. Codex runs tasks in a sandbox. A research agent reads fifty pages and writes a summary. Each one acts, not just talks.
What is a multi-agent system?
A multi-agent system is two or more agents working on related work, where the output of one feeds the others. A writer and an editor. A coder and a reviewer. A researcher who finds leads and a seller who calls them. The value comes from the hand-offs. The risk comes from the hand-offs too.
What is agent orchestration?
Orchestration is the coordination layer: who does what, in what order, with what information, and who checks it. Some tools do it in code, like CrewAI's hierarchical process, where a manager agent assigns tasks to the others. Some do it inside one product, like Claude Code's agent teams, where a lead session coordinates teammate sessions. In an AI office, a chief agent does it in plain language.
What is a personal agent?
A personal agent is an agent built for one person. It knows what that person told it, works in that person's accounts and bills that person. Claude Code, Codex, Grok Bot, Meta Muse, OpenAI Dots and Hermes are personal agents. They can be excellent. They are not built to be part of a team, because nothing in them knows about anyone else's agents.
What is a chief?
A chief is the agent that runs your other agents, speaks for you and answers only to you. Think of a chief of staff. It hires the other agents, hands out the work, checks results before they reach you, and only interrupts you when there is a real decision to make. We wrote a full guide on what an AI chief of staff actually does.
What is a teammate?
In Vestra, a teammate is an agent hired for a whole job with goals, rather than for one-off tasks. It has a personality, goals, skills, apps, routines, memory and an engine underneath. You shape every part. It holds the job for months and gets better at it each week.
So when people ask "how do I manage multiple AI agents?", they usually mean one of three things:
- "How do I stop them getting in each other's way?" That is coordination.
- "How do I stop them doing something I didn't want?" That is control.
- "How do I stop them eating my whole day?" That is the management tax, and it is the one this guide cares about most.
Why do more AI agents often mean more work for you?
More AI agents often mean more work because each personal agent needs its own brief, its own check, its own approvals and its own login. Nobody connects them, so you become the glue. You carry context from one to the next, chase results, and check every "done". The work you saved gets spent on supervising.
Call it the management tax. It shows up in six ways.
1. You brief the same thing again and again
Your coding agent doesn't know what your sales agent learned on Tuesday. Your writing agent doesn't know your best customer prefers short, formal emails. So you tell each one. Then you tell them again next week, because the conversation ended and the context went with it. The Vestra handbook puts it plainly: people "paste the same context in again and again."
2. You carry work between agents by hand
The research agent finishes a list of leads. The outreach agent needs that list. Nothing moves until you copy it across. Multiply that by every hand-off in a week and you have a part-time job as a courier.
3. You chase every result
"Is it done?" Then "is it right?" Each agent reports back to you, on its own schedule, in its own place. You check the inbox, then Slack, then the terminal, then the other app. Nobody is tracking the whole picture except you.
4. You check work that came back "done"
Agents are confident. "Done" from an agent can mean "I wrote something" rather than "it works". So you test the code, open the draft, click the link, check the number. With one agent, that's fine. With six, checking becomes your day.
5. You approve things all day
To stay safe, you set every agent to ask before acting. Sensible. But now six agents ask you small questions all day, and most of them don't need you. The pings train you to tap "yes" without reading, which is the opposite of safe.
6. You manage six bills and six sets of logins
Each personal agent has its own plan, its own usage limit and its own access to your tools. Who can see your CRM? Which agent has your card? What did last month cost, and which agent spent it? Nobody can answer except you, and only after an hour with a spreadsheet.
None of this is a flaw in any single agent. It is what happens when tools built for one person are used as if they were a team. The agents are fine. The structure is missing.
More agents should mean less of your time. If it means more, the agents are not the problem. The missing team around them is.
Why are most AI agents built for one person?
Most AI agents are built for one person because they grew out of chat apps, where one person types and one agent answers. Their memory, history, permissions and billing all belong to that one account. Claude Code, Codex, Grok Bot, Meta Muse, OpenAI Dots and Hermes each serve the person who started them, and none can see the others.
That design made sense. The first job of an agent was to be useful to someone. Being useful to a team is a different and harder problem: it needs shared memory, rules that hold for everyone, and a way for one agent to hand work to another without a person carrying it.
Look at how the best-known agents are shaped:
- Claude Code is Anthropic's coding agent. It works in one developer's terminal, editor or app, on that person's Claude plan. It can coordinate other Claude Code sessions, but only Claude Code sessions, and only inside one session. See Vestra vs Claude Code.
- Codex is OpenAI's coding agent. It can spawn subagents inside a chat and combine their answers, all on the same account.
- Grok Bot is xAI's assistant, built around one person's chats and account. See Vestra vs Grok Bot.
- Meta Muse is Meta's assistant, built for one person across Meta's apps. See Vestra vs Meta Muse.
- OpenAI Dots are personal agents inside ChatGPT, each one tied to one user. See Vestra vs OpenAI Dot.
- Hermes is an open agent you run yourself, for yourself.
- OpenClaw is a free, open-source assistant you host and secure yourself, built for one trust boundary. See Vestra vs OpenClaw and our list of OpenClaw alternatives for businesses.
Each of these can be brilliant at its job. The problem is the gap between them. Your Claude Code session has no idea your Codex session exists. Your Grok chats don't reach your Muse assistant. Two people on the same team, each with their own agents, have agents that can't see each other at all.
Here is the contrast in one table, written as a list so it reads on any screen:
- Who it works for. Personal agent: the one person who started it. AI office: a whole team, with a chief for each person.
- Who it talks to. Personal agent: you, in its own app. AI office: you, through your chief, and other agents directly.
- What it remembers. Personal agent: your chats with it. AI office: one memory every agent reads, with a source for every line.
- How work moves. Personal agent: you copy it across. AI office: the chief hands it over, context and all.
- Who checks the work. Personal agent: you do. AI office: a test, a second agent, the source or a person, before it reaches you.
- Rules. Personal agent: set per product, if at all. AI office: one set of office rules, the same on every engine.
- Bills. Personal agent: one per product. AI office: one plan and one receipt for every piece of work.
The point is not that personal agents are bad. It is that a pile of personal agents is not a team, however good each one is. To manage several, you need something that sits above them.
What are the ways to manage multiple AI agents today?
There are six ways to manage multiple AI agents today: by hand, inside one vendor's product, with a developer framework, with an enterprise control plane, with one assistant that wears many hats, or in an AI office. They differ in who does the coordinating, whether agents from different companies can work together, and how much of it lands on you.
Here is each one, with what it is good at and where it stops.
1. By hand: you are the manager
What it is. You run each agent in its own app and connect them yourself. Copy the research into the writing agent. Paste the code into the review agent. Keep a doc of "context to paste".
Good for. Two agents, occasional use, no setup.
Where it stops. Everything in the management tax section above. It scales with your time, and your time doesn't scale.
2. Inside one vendor: teams of the same agent
What it is. The large coding agents now coordinate copies of themselves.
Claude Code has agent teams. Anthropic's docs describe one session acting as "the team lead, coordinating work, assigning tasks, and synthesizing results", with teammates that "work independently, each in its own context window, and communicate directly with each other." The team shares a task list where tasks are pending, in progress or completed, and teammates can claim the next one. You can even set the model for each teammate.
Codex has subagents. OpenAI's docs describe them as a way of "spawning specialized agents in parallel and then collecting their results in one response". You can define custom agents in small files with their own instructions and model, and Codex handles the spawning, routing and closing.
Good for. One developer splitting a big coding job: one teammate on the front end, one on the back end, one on tests, or three reviewers each checking for something different.
Where it stops. Read the limits in the vendors' own words. Claude Code's agent teams are "experimental and disabled by default". There is "one team per session", "no nested teams", and "the lead is fixed". When the session ends, the team config is removed. Resuming a session does not bring back in-process teammates. The docs also warn that agent teams "use significantly more tokens than a single session" and recommend starting with three to five teammates. Codex's docs say subagent workflows "consume more tokens than comparable single-agent runs."
Most of all: a Claude Code team is made of Claude Code. A Codex team is made of Codex. Neither can put the other on its team. And both are teams for one user, inside one session, not a standing team that holds jobs for months.
3. Developer frameworks: build your own crew
What it is. Libraries like CrewAI let developers define agents with roles, goals and tools, then choose how they work together. CrewAI's hierarchical process adds a manager agent that "assigns tasks to crew members based on their roles, capabilities, and available tools" and reviews their output. You set the manager's model in code.
Good for. Engineering teams building an agent workflow into their own product, where they want full control of every step.
Where it stops. It is code. Someone has to write it, host it, monitor it, secure it and fix it when a model changes. There is no office, no shared memory you can open and read, no receipts unless you build them, and no chief who answers your phone. It is a kit for building a team, not a team.
4. Enterprise control planes: manage agents like IT assets
What it is. Big platforms now offer a registry and rulebook for every agent in a company.
Microsoft says Agent 365 lets organizations "observe, govern, and secure the growing number of agents within organizations." Admins "view all their agents in a single, centralized registry", with permissions through Microsoft Entra and data protection through Purview. Microsoft's page says it became generally available on 1 May 2026 for commercial customers "on a per user basis", and that it "works best when using Microsoft E5 as a pre-requisite."
OpenAI's Frontier is pitched as a way to "operate AI coworkers on a single enterprise platform". OpenAI's page lists business context from company systems, agents "working together in parallel", agent identities with access limited to "exactly what each task requires", and actions that are "visible and auditable". It is aimed at large enterprises, often with OpenAI engineers helping set it up, and the page lists no public price.
Good for. A large company's IT and security team that needs to know which agents exist, what they can touch and who approved them.
Where it stops. These tools manage agents the way IT manages laptops. They answer "which agents do we have, and are they safe?" They don't answer "who is doing the work for me today, and what needs my decision?" A small business owner or a team lead doesn't need a registry. They need someone to run the agents.
5. One assistant, many hats
What it is. Some products avoid the multi-agent problem by being one agent that does many jobs. Lindy calls itself "an AI employee for your whole team." Its home page says "your whole team shares one Lindy, so what it learns compounds," and that most teams give it several jobs at once, which it can switch between in the same day.
Good for. A team that wants one shared assistant in Slack, email and iMessage, with many integrations. Lindy lists 3,000+ integrations on its pricing page.
Where it stops. One agent wearing many hats is still one agent. It can't put a careful reviewer on one model and a fast writer on another and have them check each other. It can't bring Claude Code or Codex into the team as members. And pricing is per person: Lindy's pricing page says "every active user in your workspace is billed, from $49.99 a month for 5,000 credits each." We compare the two approaches in Vestra vs Lindy.
6. An AI office: a chief and a team of teammates
What it is. An AI office gives your agents what a human team has: a lead, jobs, a shared memory, rules and a record. In Vestra, your chief runs your teammates. Each teammate holds a whole job and runs on the engine that suits it: Vestra's own, Claude Code or Codex today. You talk to your chief. It hands out the work, checks it and brings you only the decisions.
Good for. Anyone running more than one or two agents who wants the work done without becoming the coordinator: founders, small businesses, operators and engineering teams that already use Claude Code or Codex.
Where it stops. Be clear on what is live. Today Vestra is live for one person and their team of agents: a chief, teammates, routines, a morning brief, a cloud computer, a memory wiki with sources, any engine per teammate, connected tools, and limits, approvals and receipts. A chief for every person on a human team, chiefs working together, the office you can walk around, spaces and access control are being built now. We list it all in the last section.
The six side by side
- Who coordinates? By hand: you. One vendor: a lead session of the same agent. Framework: code you write. Control plane: IT admins. One assistant: the assistant itself. AI office: your chief.
- Agents from different companies on one team? By hand: yes, but you carry everything. One vendor: no. Framework: yes, if you build it. Control plane: registered, yes; working together, depends. One assistant: no, it is one agent. AI office: yes, Vestra's own, Claude Code and Codex today.
- Does the team last? By hand: as long as you keep it going. One vendor: one session. Framework: as long as you run it. Control plane: yes. One assistant: yes. AI office: yes, teammates hold jobs for months.
- Shared memory? By hand: a doc you paste. One vendor: project files and the session. Framework: whatever you build. Control plane: company data connections. One assistant: one assistant's memory. AI office: one wiki every agent reads, with sources.
- Who checks the work? By hand: you. One vendor: you and the lead. Framework: the manager agent, if set. Control plane: audit logs after the fact. One assistant: you. AI office: a test, a second agent, the source or a person, before it reaches you.
- Who is it for? By hand: anyone. One vendor: one developer. Framework: engineers. Control plane: enterprise IT. One assistant: teams that want one shared helper. AI office: anyone who wants a team, not a toolbox.
What is the difference between managing agents and running them as a team?
Managing agents means you are the hub: every brief, hand-off, check and approval passes through you. Running them as a team means the agents have a lead, share one memory, hand work to each other and check each other, so only real decisions reach you. The first grows with every agent you add. The second gets lighter.
Think about how a good small company works. The founder doesn't tell the bookkeeper what the salesperson said on a call. The salesperson wrote it in the CRM. The bookkeeper read it. The founder only hears about it when a discount needs approving. The work flows between people, and the founder sees decisions.
Now think about how most people run agents. Every single hand-off goes through them. The agents never talk. The founder is the CRM.
Here are the differences that matter:
- Where work goes when it's finished. Managed: back to you. Team: to the next agent who needs it, with the context attached.
- Who knows the whole picture. Managed: only you. Team: the lead agent, which can tell you what everyone is doing and why, at any moment.
- How mistakes get fixed. Managed: you correct one agent, and the others make the same mistake next week. Team: the correction becomes a lesson in the shared memory, and every agent's next piece of work starts from it.
- What reaches you. Managed: everything. Team: decisions, with the facts and a suggestion.
- What happens when you're asleep. Managed: nothing moves. Team: the work continues within the limits you set, and a short brief is waiting in the morning.
The Vestra handbook sums up the gap with four words for life without a team: you brief every agent by hand, you carry work between them, you chase every result, and you click through forms and settings for every request. The team version flips each one: brief once, hand off, checked, just talk.
Who should manage your AI agents: you, or another agent?
Another agent should manage your AI agents, and you should manage that one. A coordinating agent, or chief, can hand out work, track every task, check results and hold questions until you're free, around the clock. You keep the goals, the limits and the decisions. That is how one person runs many agents without becoming a full-time manager.
This is the single most important choice in this guide. Everything else follows from it.
Why it shouldn't be you
You are the most expensive and least available member of the team. You sleep. You have meetings. You can hold maybe a handful of open threads in your head. Agents can work at 3 am, but if every hand-off waits for you, they don't.
You are also the wrong person to do routine coordination. "Has the research agent finished? Then pass its list to the outreach agent and tell it to skip anyone we've emailed before." That is a clear rule. An agent can follow it a thousand times without getting bored.
Why it should be one agent, not many
If every agent can interrupt you, you will be interrupted all day. If one agent speaks for all of them, you hear from one voice. The handbook puts it in a line: "Instead of a dozen agents pinging you, you hear from one. Your chief."
One coordinator also means one place to ask questions. "What is everyone working on?" "Why did the reviewer send that back?" "What did the team spend this week?" One agent can answer all of these because it hands out the work and receives the results.
What a chief does
In Vestra, every person has a chief. The handbook gives it three jobs:
- It runs your agents. It hires them, hands out the work, makes sure every result is checked before it reaches you, and teaches them how you like things done. When a teammate writes a post that misses your tone, the chief sends it back with the reason, and the reason becomes a lesson.
- It speaks for you. When a colleague's chief asks for something, yours answers from what you've already shared, holds the question until you're free, or says no. (Chiefs working together across a human team is being built now.)
- It answers to you. It never acts above the freedom you've given it. Anything big waits for your yes, and it can always tell you what every agent on your team is doing and why.
What you keep
Putting an agent in charge doesn't mean handing over control. You keep:
- The goals. What each teammate's job is for, and how you'll know it's working.
- The lines. What each agent may do alone, what it must ask about, and what it may never do.
- The money. Card limits, per-task caps and the daily budget.
- The decisions. Anything over a limit, anything new, anything that deletes.
The chief handles the rest. That is the trade: you give up the coordination, not the control.
What a chief is not
A chief is not a dashboard you have to read, and it is not an agent that hides things from you. Ask it anything about your team and it answers. And it is not a single assistant doing everyone's job either. It is a manager, not a worker. The work is done by teammates who each hold a job.
How do you give each AI agent a clear job?
Give each AI agent a whole job with goals you can check: what it is for, which apps it may use, what it does on a schedule, and what it must ask you about first. An agent with a job decides what to do next. An agent with only prompts waits for you to tell it, every time.
Most agents work one prompt at a time. You ask, it answers, and tomorrow you start again. That is fine for a one-off question. It is exhausting for anything that repeats, because you become the agent's to-do list.
Asks, routines and goals
The Vestra handbook splits a teammate's work into three kinds, and the split is useful whatever tools you use:
- An ask is one-off. "Compare the three biggest rivals on price by Thursday." It's finished when it's delivered.
- A routine repeats. It runs on a schedule, like a market note every Monday at 9, or the moment something happens, like a rival changing its prices.
- A goal is the whole job, held for months. "Know our market better than anyone." "Get us paid on time, and always know our runway."
The goal is what turns an agent into a teammate. Asks come and go, routines keep their rhythm, and the goal sits underneath both, deciding what is worth doing next. An agent that owns "know our market" doesn't wait to be told that a rival's new prices matter. Its goal says they do.
Write the job down
When you hire a person, you write a job description. Do the same for agents. In Vestra, you hire a teammate by describing the job in a sentence to your chief, which asks a few manager-style questions (what matters most, where the work lives today, what must never happen without you) and writes a teammate card:
- The job in one line. "Get us paid on time, and always know our runway."
- Goals you can check. Every invoice out on the 1st. Nothing unpaid past 30 days. Runway in your Slack every Monday.
- The apps it may use. Stripe, Xero, Gmail, Slack. Only those.
- Its first routines. Invoices on the 1st. A friendly nudge the moment a payment fails.
- What it must ask first. Refunds, write-offs, and anyone it hasn't written to before.
You read the card, change anything, and say yes. Nothing is tucked away in settings you never see.
Shape the seven parts
Every Vestra teammate is made of seven parts, and you can change each one, either on its profile or by saying it out loud ("be a little more formal with this client"):
- Personality: tone, length, words it never uses.
- Goals: what the job is for.
- Skills: ways of working it knows, ready-made or built for your business.
- Apps: the tools it may use for this job, and only those.
- Routines: what it does on a schedule or when something happens.
- Memory: what it has learned working with you.
- Engine: what it runs on, which you can switch any time.
Use skills so jobs start strong
A skill is a way of doing a kind of work, written down so a teammate can pick it up. Vestra comes with ready-made skills for Sales, Bookkeeping, Content, Customer care and Research, and you can add custom skills built around how your business works. A custom skill reads like a short playbook: "Start renewals 30 days before the date. Write to the person who signs. Offer the group discount and nothing more without the founder's yes."
One job per agent, one owner per job
Two rules keep a team tidy:
- Don't give two agents the same job. If two agents both "handle customer email", they will both answer, or neither will. Split by outcome: one answers, one follows up on refunds.
- Every job has one human owner. The person the teammate works for sets its limits and makes its decisions. When something needs a yes, everyone knows whose yes it is.
How do you stop briefing every agent from scratch?
You stop briefing every agent from scratch by keeping one shared memory that every agent reads before it acts, with a source for every fact. When one agent learns something, the others know it. When you correct one, the lesson sticks for all of them. Briefing becomes a one-time thing, not a daily chore.
Re-briefing is the biggest hidden cost of running several agents. Every personal agent starts each conversation knowing only what it was told in that conversation, plus whatever its own memory feature kept. None of them share. So the facts that matter most (who your customers are, how you like things written, what went wrong last time) get typed again and again.
What a shared memory should hold
A useful team memory holds the same things a good new hire would ask about in week one:
- The people. Who does what, and how they like to work.
- The customers. Every account, every contact, every promise made.
- The decisions. What was decided, and why.
- How you like things done. Rhythms, rules and taste. "Emails to clients: short, warm, never the word excited."
- The numbers. Revenue, spending and targets.
- What went wrong last time, so it doesn't go wrong again.
Why sources matter
A memory you can't check is a memory you can't trust. In Vestra the memory is a wiki you can open and read, with a page for each customer, person, project and decision, all linked together. Every line has a source: a small number that tells you where it came from, whether an email, a call, a record in your CRM, a teammate's work or something a person said. If a line looks wrong, open its source. If it is wrong, edit it, and your edit carries your name.
That is the difference between memory and guesswork. When an agent does something odd, you can find out why, and change the fact that caused it.
Where the memory comes from
Nobody should have to sit down and write the memory. The handbook describes four sources: the onboarding call, the work your teammates do, the tools you connect, and your team's conversations. Connect your email and CRM and the memory starts from your history, so on day one it already knows your biggest customers and what you've agreed with them.
Brief once, then hand off
The other half of "never brief twice" is the hand-off. When work moves from one agent to another, the context should move with it: what was asked, by whom, why, by when, and what "done" looks like. In Vestra the chief writes that brief once, from what already exists (the client's email, the call, the relevant memory pages), and every agent that picks up the work starts from it. Private notes stay behind.
What's live and what's coming
Be precise here. Today in Vestra, the memory that learns, a wiki of what your team knows with a source for every line, is live for one person and their team of agents. The full shared brain for a whole company, where one person's correction reaches every colleague's agents, is on the roadmap after the network pieces ship. Exporting the memory as plain Markdown files that open in Obsidian is part of the design, so what your team knows is never locked in.
How do you know an agent's work is actually done?
You know an agent's work is done when something other than that agent has checked it: a test that passes, a second agent's review, the original source, or a person's yes. Count nothing as done on the agent's own word. Make the check part of the job, and have the proof travel with the result.
"Done" is the most expensive word on any team when it isn't true. With one agent you can check everything yourself. With six, you can't, and you shouldn't have to.
The four kinds of check
The handbook lists four, and the right one depends on the work:
- A test. Code gets tests. "42 of 42 tests passed" is proof. "I think it works" is not.
- A second agent. A reviewer reads every change and tries it. If it finds a problem, the work goes back with the reason.
- The source. A fact gets checked against where it came from. "Two rivals raised prices" comes with each rival's pricing page, read today.
- A person. Anything that speaks for you in public, like an email to every customer, gets a human yes.
Why a second agent on a different engine helps
Agents built on the same model tend to make the same mistakes, and to agree with each other's mistakes. A reviewer on a different engine reads the work with fresh eyes. That is why many developers already use Claude Code and Codex together, one writing and one reviewing. We cover that setup step by step in How to use Claude Code and Codex together.
In the handbook's example, one teammate builds on Claude Code and another reviews on Codex. The reviewer reads every change, tries it on a test account, and asks for one fix before signing off. Only then does the chief report the work as finished, with the test results and the review notes attached.
Make the check part of the job
Don't add checking as an afterthought. Put it in the job:
- For code: "Done means the tests pass and a second agent has reviewed it."
- For research: "Done means every number links to its source."
- For anything public: "Done means I have read it and said yes."
Then tell your coordinating agent never to report something as finished, to you or anyone else, until the check has passed.
What's live and what's coming
Two separate teammates on two different engines, one building and one reviewing, works in Vestra today, because any engine per teammate is live. The full proof trail, where every hand-off between people's agents is checked and written down for both sides, is listed in the handbook as being built now.
How do you keep control without approving everything?
Keep control by deciding which actions always need you and letting agents handle the rest within limits. Spending over a limit, deleting something and contacting someone new should always wait for a person. For everything else, start agents on "ask first", move them to "suggest" and then "act, then tell me" as they earn it.
The instinct with agents is to approve everything. It feels safe. It isn't, for two reasons. First, it buries the real decisions under small ones. Second, it trains you to tap yes without reading. A good control setup asks you less often, about things that matter more.
Three things that always wait for you
In Vestra, three kinds of action always wait for a person's yes, however long a teammate has worked for you and however small the thing is:
- Spending over your limit. Anything above a card's monthly limit, a task's cap or the day's budget.
- Deleting something. A file, a page, an email, a record. Gone is gone, so it asks.
- Contacting someone new. The first email, call or message to anyone you haven't dealt with.
You can add your own lines in a sentence: "Always check with me before anything goes to our biggest client." If you don't answer, nothing happens. The agent waits and tells whoever was waiting on it that it is waiting on you.
Freedom that grows, but only when you move it
Everything outside those lines is yours to tune, teammate by teammate and task by task. For each kind of work, a teammate can:
- Ask first. Before any judgement call, it asks how you want it done.
- Suggest. It has seen enough to have a view, so it brings a proposal and waits for your tap.
- Act, then tell you. For things it has learned well, it just does them and shows you what it did.
The handbook shows a writing teammate moving from asking about tone in week one, to suggesting a better posting time in week four, to answering comments in your voice by week eight. The key detail: a teammate only gets more freedom when you move the setting. It never promotes itself.
Decisions, not status updates
The other half of control is how decisions reach you. A good decision request has:
- The question in one line.
- The facts that matter.
- What the coordinating agent suggests, and why.
- The choices, with the suggestion as number 1.
Then you can decide in seconds, from anywhere. Status updates ("just checking in", "all quiet here") shouldn't reach you at all. The handbook is blunt about it: "A quiet day in Vestra is a day when the work got done and none of it needed you."
Rules that hold on every engine
If your agents run on different engines, your rules must not depend on the engine. In Vestra the office rules are the same whether a teammate runs on Vestra's own, Claude Code or Codex: the same yeses, the same limits, sealed logins and the same receipts. No engine can raise its own limit, approve its own payment or give itself access to an app.
Outside agents inform, never command
As more of the world runs on agents, your agents will receive messages from other people's agents. The rule should be firm: a note from outside can inform, but it can never approve a payment, change a permission or create a rule. Claude Code's own agent-team docs take a similar line inside one team: a teammate "can't approve a permission prompt or supply consent on your behalf". Vestra applies the same principle to every message from outside your company.
How do you stop multiple AI agents from overspending?
Stop multiple agents from overspending with layered caps: a limit on any single task, a limit on the whole day, a monthly limit on each agent's card, and a check before any unusually big job. Then put every credit and payment on a receipt that shows which agent spent it and why.
Agents cost money in two ways. They use model time and tools, which you pay for in tokens, credits or usage limits. And some of them buy things: a contact list, a software plan, an ad test. With one agent, you can keep an eye on both. With several, on several plans, you can't.
The vendors are open about the token side. Anthropic's docs say agent teams "use significantly more tokens than a single session" and that token costs scale with the number of active teammates. OpenAI's Codex docs say subagent workflows "consume more tokens than comparable single-agent runs." Running more agents is more spend by design.
The four limits
Vestra stacks four guards:
- A cap on any single task. If one piece of work would cost more, it stops and asks.
- A cap on the whole day, up to $100 a day.
- A check before big tasks. Before anything unusually large, by default anything over 50 credits, your chief tells you what it will cost and asks.
- Card limits per agent. Each agent's card has a monthly limit set by the person it works for. (Per-agent cards in a vault are on the roadmap; today's limits, approvals and receipts cover credits and the caps above.)
When a cap is reached, work doesn't fail halfway. The agent stops at a sensible point, says what it finished and what's left, and waits.
One unit, one receipt
Paying for six products in six units makes it impossible to compare. Vestra uses one unit for everything: one credit is one cent, the same for model time, actions in your apps, the computer, searches and calls, and the same on every engine. Every piece of work gets a receipt.
The handbook's example receipt for a two-engine coding fix:
- Builder, on Claude Code: 142 credits.
- Reviewer, on Codex: 58 credits.
- Chief, keeping everyone posted: 9 credits.
- Total: 209 credits, which is $2.09.
That is what "where did the money go?" should look like: one list, per agent, per job.
Plans and credits
Vestra plans include monthly credits, and unused credits roll over:
- Lite: $19 a month ($17 billed yearly), up to 3 teammates, 2,000 credits a month.
- Pro: $97 a month ($87 billed yearly), up to 20 teammates, 10,000 credits a month, phone calls.
- Max: $197 a month ($177 billed yearly), up to 50 teammates, 20,000 credits a month.
- Ultra: $497 a month ($447 billed yearly), up to 150 teammates, 50,000 credits a month.
- Enterprise: from $4,000 a month, scoped in writing.
Every new office starts with 1,000 free credits. In India, plans are billed in rupees with GST included.
How do you mix agents from different companies, like Claude Code and Codex?
To mix agents from different companies, you need a layer above them that owns the job, the memory and the rules, so each agent becomes an engine underneath a teammate. In Vestra you pick the engine per teammate: Vestra's own, Claude Code or Codex today. Switch any time, and the job, memory and rules stay.
This is where the personal-agent world breaks down. Claude Code can lead a team, but only of Claude Code. Codex can run subagents, but only Codex subagents. If you want a builder on one and a reviewer on the other, you are the bridge.
Engines underneath, teammates on top
The handbook describes every teammate in two layers. On top is everything that makes it yours: its job and goals, skills, apps, routines, memory, kit and the rules it works under. Underneath is the engine, the part that reads the task, decides the next step and does it.
Because the engine sits underneath, you can change it without touching anything above. A teammate's job, memory and history belong to the teammate, not to the engine. If a new engine suits the job better, trying it is one change, not a rebuild. If it isn't better, switch back.
A different engine for each job
You pick the engine teammate by teammate, so one team can use several at once. The handbook's example puts a builder on Claude Code and a reviewer on Codex, so the code is written on one engine and read by another. Every chief runs on Vestra's own engine. Each teammate's engine shows on its desk tag and its profile, so you always know what runs on what.
You don't need to know how engines differ. When your chief hires a teammate, it suggests an engine and says why, in plain words. Take the suggestion, pick another, or let your chief choose job by job.
Be clear about which engines are live
The engine picker in the handbook also shows Gemini, Grok and Muse. Today, the live engines are Vestra's own, Claude Code and Codex. Treat the others as coming, not as something to plan a team around this week.
What this replaces
Without a layer like this, mixing vendors means:
- Two subscriptions and two bills.
- Two memories that drift apart.
- Two permission systems to keep in sync.
- You, carrying every diff and brief between them.
With it, you get one plan, one memory, one set of rules and one receipt, with the engine as a choice per job. That is the core of what we mean by an AI office. For the full picture, read What is an AI office?.
How many AI agents should one person run?
Start with one to three agents, each with a clear whole job, plus one agent that coordinates them. Add another only when a job keeps eating your week and the current agents are running without you. The right number is set by how much coordination you can hand off, not by how many tools you can sign up for.
There is no magic number, but there are useful signals.
What the vendors say
Anthropic's own advice for Claude Code agent teams is to "start with 3-5 teammates for most workflows," and it warns that "three focused teammates often outperform five scattered ones." It also notes diminishing returns: past a point, adding teammates doesn't speed up the work in proportion, and coordination overhead grows. That advice is for parallel coding work inside one session, but the logic holds for any team.
A simple way to decide
Ask three questions before adding an agent:
- Is there a whole job for it? Not a task, a job with goals you can check. If you can't write the one-line job, you don't need the agent yet.
- Are the current agents running without you? If you are still re-briefing and chasing the ones you have, another agent will make it worse.
- Who will check its work? If the answer is "me, every time", design the check first.
A good first team
For most small businesses, a strong first team looks like this:
- A chief that runs everything and talks to you.
- One teammate on the job that eats the most of your week. For many founders that's email and follow-ups, or getting paid, or research.
- One teammate that checks. A reviewer for code, or a researcher who checks facts against sources.
The handbook's advice for a first hire is the same: "A good first hire is the job that eats the most of your week."
How big can it get?
In Vestra the ceiling is set by plan: up to 3 teammates on Lite, 20 on Pro, 50 on Max and 150 on Ultra. The point of a chief is that the number you manage stays at one, however many teammates sit behind it.
What does a week with multiple agents look like, the old way and the team way?
The old way, a week with several agents is spent briefing, copying, chasing and approving, and most work waits for you. The team way, you set goals on Monday, read a short brief each morning, answer a few decisions with one tap, and the agents hand work to each other in between. Same agents, very different week.
Here is the same week, run twice. It's a small company with a founder, a coding agent, a review agent, a research agent and a writing agent.
Monday
The old way. The founder opens four apps. Tells the research agent which rivals to watch. Pastes the product notes into the writing agent. Explains the bug to the coding agent. Copies yesterday's review comments into the review agent. It's 11 am before anything starts.
The team way. The founder tells the chief, in one sentence, "This week: fix the reminder bug, write the launch post, and tell me if any rival changes prices." The chief already knows the product, the rivals and the writing style from the shared memory. It hands each job to the right teammate. Work starts while the founder makes coffee.
Tuesday
The old way. The coding agent says the fix is done. The founder tests it. It isn't. Back to the coding agent with the error. Then the founder remembers the review agent never saw it, so copies the diff across.
The team way. The builder on Claude Code finishes the fix. The reviewer on Codex picks it up, runs the tests and asks for one change. The builder fixes it. The reviewer signs off. The chief reports it done, with the test results attached. The founder taps to read the proof, or doesn't.
Wednesday
The old way. The writing agent's draft calls the product "exciting" twice. The founder corrects it. Next week the same agent, or a different one, does it again.
The team way. The founder sends the draft back once: "Never 'exciting'." The correction becomes a lesson in the memory, with the founder as its source. The next piece of work starts from it.
Thursday
The old way. The research agent found a rival's price cut, but it's in a chat thread the founder hasn't opened. Sales finds out on a call.
The team way. The research teammate owns "know our market". Its routine notices the price cut, checks it against the rival's pricing page, and the chief puts one line in the founder's morning brief, with a proposal: "Make a one-page comparison for this week's calls?" Yes, in one tap.
Friday
The old way. The founder spends an hour working out what the agents cost this month, across four bills, and can't tell which agent used what.
The team way. The founder asks the chief, "What did the team cost this week, and what did we get for it?" The answer comes back as receipts, per teammate, per job, in one unit.
The difference, counted
- Briefs written by the founder. Old way: dozens, many repeated. Team way: one per goal.
- Hand-offs carried by hand. Old way: every one. Team way: none.
- "Is it done?" checks. Old way: every result. Team way: open the proof only when you want to.
- Decisions. Old way: buried in pings. Team way: a few, each with a suggestion.
- Bills to reconcile. Old way: one per product. Team way: one, with receipts.
The founder in the team way still makes every decision that matters. They just stopped being the courier.
What are the most common mistakes when managing multiple AI agents?
The most common mistakes are adding agents before jobs are clear, letting every agent talk to you, giving two agents the same job, trusting "done" without a check, approving everything, keeping no shared memory, and running agents on separate bills with no limits. Each one turns agents back into work for you.
1. Adding agents before you have jobs for them
A new agent feels like progress. Without a written job, it's a new thing to supervise. Write the one-line job first. If you can't, wait.
2. Letting every agent talk to you
Six agents each pinging you is six managers. Route everything through one coordinator, and have it bring you decisions, not updates.
3. Two agents, one job
If two agents both "handle support", you get double answers or none. Split jobs by outcome and give each one a single owner.
4. Trusting "done"
An agent saying it's done is not proof. Make a test, a second agent, the source or a person part of every job's definition of done.
5. Approving everything
It feels safe and isn't. You end up approving on autopilot. Fix three hard lines (spend, delete, contact someone new) and tune the rest per agent.
6. No shared memory
If every agent has its own memory, every correction has to be made once per agent. Keep one memory with sources that every agent reads.
7. Same engine for writer and reviewer
A reviewer on the same model tends to miss the same mistakes. Where it matters, put the checker on a different engine.
8. No budget, or six budgets
Agents running on separate plans with no daily cap are how surprise bills happen. Set per-task and per-day caps, and get one receipt per piece of work.
9. Leaving logins lying around
Pasting API keys and passwords into agents spreads them everywhere. Use sealed logins: an agent uses an app within the scope you allow, never sees the password, and you can revoke it in one tap.
10. Never revisiting the job
Jobs change. Once a month, look at each teammate's goals and ask what you'd ask a person: is this still the job, and how is it going?
How do you start managing multiple AI agents this week?
Start by listing your agents and the hand-offs you do by hand. Pick the job that eats most of your week, write it as a whole job with goals, and give it to one agent. Put a coordinating agent in charge, set your three hard lines and a daily cap, and add a second agent once the first runs without you.
Here is a plan you can follow, with or without Vestra.
Day 1: Count the tax
Write down every agent you use and every time this week you:
- Pasted the same context into an agent.
- Copied a result from one agent to another.
- Checked whether something an agent said was done really was.
- Approved something small.
That list is your management tax. It tells you which hand-offs to fix first.
Day 2: Write one whole job
Pick the job that costs you the most time. Write it as a teammate card: the job in one line, two or three goals you can check, the apps it may use, its routines and what it must ask first.
Day 3: Put one agent in charge
Choose your coordinator. In Vestra, that's your chief: name it, tell it about your work in a short conversation, and let it suggest your first teammates. Outside Vestra, it might be a lead session in Claude Code for a coding job, or a manager agent in a framework if you're building one.
Day 4: Set the lines and the budget
Decide what always waits for you (spend over a limit, deletes, first contact with anyone new), set a per-task cap and a daily cap, and decide how much each agent may do alone. Start everything on "ask first".
Day 5: Build the memory
Connect your email, calendar, CRM and chat so the shared memory starts from your history. Then correct one thing and check that the correction sticks.
Week 2: Add a checker
Add a second teammate whose job is to check the first: a reviewer on a different engine for code, or a researcher who verifies facts against sources.
Week 3 and after: Loosen as trust grows
Move tasks the agents handle well from "ask first" to "suggest", then to "act, then tell me". Add the next teammate only when the first two run without you.
If you want to try this in Vestra, plans start at $19 a month and every new office starts with 1,000 free credits. You can see how Vestra compares with the tools you may already use on our comparison pages, such as Vestra vs Lindy, Vestra vs Claude Code and Vestra vs Perplexity Teammates, and in our guide to the best AI agents for business.
What is live in Vestra today, and what is still being built?
Live in Vestra today, for one person and their team of agents: a chief and teammates with routines and a morning brief, a cloud computer, calls and email from your chief, connected business tools, a memory wiki with sources, any engine per teammate, and limits, approvals and receipts. Team-wide features like chiefs working together are being built now.
We'd rather you know exactly what you're getting. This is the order from the Vestra handbook's "Where We Stand" chapter.
Live today, for one person
- A chief and a team of teammates. Hire, shape and run teammates, with routines and a morning brief.
- A cloud computer. Watch your team work in a real browser, and take over any time.
- Calls and email from your chief. Its own number and address, with phone calls from the Pro plan up.
- Connected business tools. Email, calendar, CRM, books and chat, connected in a click, with 2,000+ apps available.
- A memory that learns. A wiki of what your team knows, with a source for every line.
- Any engine, per teammate. Vestra's own, Claude Code or Codex, picked by you or your chief.
- Limits, approvals and receipts. Daily and per-task caps, your yes on money, every credit itemised.
- Your chief in the app, Slack, Telegram and email. On the web and in the desktop app for Mac.
Building now: the network
- A chief for every person, named by them.
- Chiefs work together: ask, answer, hold or say no, and hand work across.
- The office you can walk around: every desk, every space and what's happening, live.
- Meetings in the office, with agents keeping the notes and sending decisions to the memory.
- Spaces: one goal, shared context, and decisions for the right person.
- Access control: private, company or network, for every teammate, space and app.
- Every hand-off checked and written down, with one record for both sides.
- WhatsApp and iMessage for reaching your chief.
Then, one at a time
- A phone and an inbox for every agent, not only the chief.
- The vault: a card and logins for every agent, sealed, with limits each person sets.
- Shared apps: software built in a sentence, used by people and agents together.
- The shared brain: one brain for the whole company, learning from every correction.
- The front door: clients and partners working with you, chief to chief.
What this means for managing multiple agents today: one person can already run a team of teammates on different engines through one chief, with one memory, one set of limits and one receipt. A whole human team, each person with a chief and the chiefs coordinating with each other, is what's being built now.
Frequently asked questions
How do I manage multiple AI agents at once?
Put one coordinating agent in charge and talk only to it. Give every other agent a whole job with goals, keep one shared memory with sources, set a few lines that always need your yes, and count work as done only when it has been checked. You set goals and make decisions; the coordinator does the hand-offs.
Can one AI agent manage other AI agents?
Yes. That is what a lead agent, orchestrator or chief does. Claude Code's agent teams use a lead session to assign tasks to teammate sessions. CrewAI's hierarchical process uses a manager agent. In Vestra, your chief hires teammates, hands out work, checks results and only brings you real decisions.
What is the best way to coordinate AI agents from different companies?
Use a layer that owns the job, the memory and the rules, and treat each vendor's agent as an engine underneath. In Vestra, each teammate can run on Vestra's own engine, Claude Code or Codex today, and you can switch engines without losing the teammate's job or memory.
Can Claude Code and Codex work on the same team?
Not natively. Claude Code's agent teams are made of Claude Code sessions, and Codex subagents are Codex. Developers combine them by hand with shared instruction files and review steps. In Vestra, one teammate can build on Claude Code while another reviews on Codex, under one chief.
What is the difference between subagents and agent teams?
In Claude Code's docs, subagents report results back to the main agent, while agent team teammates share a task list, claim work and message each other directly. Both run inside one session for one user. Codex's subagents work like the first: parallel helpers whose results are combined into one response.
How do I stop AI agents from making mistakes the others repeat?
Keep one shared memory that every agent reads before it acts. When you correct one agent, the correction should become a lesson with its source, so every agent's next piece of work starts from it. Without shared memory, you have to make the same correction once per agent.
How do I stop AI agents from spending too much money?
Set a cap per task, a cap per day, a monthly limit per agent's card, and a check before unusually big jobs. Make spending over any limit wait for your yes, and get a receipt for every piece of work. In Vestra the daily cap goes up to $100 and big tasks over 50 credits ask first by default.
What should always require human approval?
Three things, whatever the agent and however long it has worked for you: spending over a limit, deleting something, and contacting someone new for the first time. Add your own lines on top, such as anything that goes to your biggest client. Everything else can be tuned per agent.
How many AI agents should a small business run?
Start with one to three teammates plus a coordinator. Give the first one the job that eats most of your week, add a second to check its work, and add more only when the first ones run without you. Anthropic suggests three to five teammates for most Claude Code agent-team workflows.
Is managing AI agents like managing people?
The structure is similar: clear jobs, shared notes, rules, checks and records. The difference is that agents can work around the clock and follow written rules exactly, so most routine coordination can be handed to another agent. You keep the goals and the decisions.
Do I need to be technical to manage multiple AI agents?
Not with an AI office. In Vestra you hire teammates by describing the job in a sentence, connect tools with a click, and set rules in plain words, like "always ask me before emailing a new client". Developer frameworks like CrewAI do need code.
What is an AI chief of staff?
An AI chief of staff, or chief, is the agent that runs your other agents, speaks for you and answers only to you. It hands out work, checks results and only interrupts you for real decisions. Read our full guide to what an AI chief of staff does.
Are tools like Microsoft Agent 365 or OpenAI Frontier the same thing?
They overlap but aim elsewhere. Microsoft says Agent 365 helps organizations observe, govern and secure their agents, with a registry for admins. OpenAI pitches Frontier as an enterprise platform to operate AI coworkers, with business context, identities and audit. Both serve large companies' IT teams. A chief serves the person who wants the work done.
How is Vestra different from Lindy?
Lindy describes itself as one AI employee for your whole team, shared in Slack and elsewhere, billed from $49.99 per active user a month. Vestra gives you a chief that runs a team of teammates, each on its own engine, from $19 a month. See Vestra vs Lindy.
What does Vestra cost?
Lite is $19 a month for up to 3 teammates and 2,000 credits; Pro is $97 for 20 teammates and 10,000 credits; Max is $197 for 50 and 20,000; Ultra is $497 for 150 and 50,000. One credit is one cent on every engine. Unused credits roll over, and every new office gets 1,000 free credits.
Can I see what every agent is doing?
Yes. Ask your chief what any teammate is doing and why, at any moment, and open any teammate's cloud computer to watch it work live or take over. The walkable office, with a live line for every desk, is being built now.
Glossary
Agent. Software that takes a goal, decides the steps and acts on its own, such as editing code, sending email or browsing a site.
Agent team. In Claude Code, a lead session plus teammate sessions that share a task list and message each other. Experimental and off by default.
Approval. A person's yes on an action an agent may not take alone. In Vestra, spending over a limit, deleting and first contact always need one.
Chief. The agent that runs your other agents, speaks for you and answers only to you. Each person names their own.
Control plane. An enterprise tool that registers, governs and secures a company's agents, such as Microsoft Agent 365.
Credit. Vestra's unit of cost. One credit is one cent, the same for model time, apps, the computer, searches and calls, on every engine.
Engine. What a teammate runs on: Vestra's own, Claude Code or Codex today. Switch it and the teammate keeps its job and memory.
Hand-off. Work moving from one agent or person to another. In a team, the context moves with it.
Management tax. The time you spend briefing, carrying, chasing, checking and approving when agents can't coordinate on their own.
Memory with sources. A shared wiki of what your team knows, where every line says where it came from, so you can check and correct it.
Multi-agent system. Two or more agents working on related work, where one agent's output feeds another.
Orchestration. The coordination of who does what, in what order, with what information, and who checks it.
Personal agent. An agent built for one person, such as Claude Code, Codex, Grok Bot, Meta Muse, OpenAI Dots or Hermes. Its memory and bill belong to that person.
Receipt. A record of what a piece of work cost, who did it and who said yes.
Routine. Work a teammate does on a schedule or when something happens, like a Monday market note.
Sealed login. Access to an app that an agent can use within the scope you set, without ever seeing the password or key.
Subagent. A helper agent spawned inside one session to do part of a task and report back, as in Claude Code and Codex.
Teammate. In Vestra, an agent hired for a whole job with goals, shaped by you, running on the engine you choose.
Sources
- Anthropic, Claude Code docs: Orchestrate teams of Claude Code sessions (agent teams), checked 13 November 2026.
- OpenAI, Codex docs: Subagents, checked 13 November 2026.
- Microsoft Learn: Microsoft Agent 365 overview, checked 13 November 2026.
- OpenAI: Frontier for business, checked 13 November 2026.
- CrewAI docs: Hierarchical process, checked 13 November 2026.
- Lindy: home page, checked 13 November 2026.
- Lindy: pricing, checked 13 November 2026.
