← All posts

What is an AI agent engine? Run each teammate on Claude Code, Codex or Vestra's own

What is an AI agent engine? Vestra blog banner

An AI agent engine is the part of an AI agent that does the thinking and the working: it reads the task, decides the next step, uses tools like a browser or a terminal, checks the result and keeps going until the job is done. Claude Code and Codex are engines, and most of them are built to work for one person at a time, alone.

That second sentence is the part most guides leave out. This guide explains engines in plain words: what they are, how they differ from the AI model underneath, what Claude Code, Codex and other engines actually do, and how to pick one for a job. Then it shows what changes when engines stop working alone. In Vestra, every teammate runs on the engine you pick, Vestra's own, Claude Code or Codex, and a chief runs them all as one team in one office, under one set of rules and one receipt.

Quick answer

  • What it is: the engine is the working layer of an AI agent. It runs the loop: read the task, plan a step, use a tool, look at what happened, decide what to do next, repeat.
  • Not the same as the model: the model (such as Claude Opus or GPT-6) does the raw thinking. The engine wraps the model with tools, memory of the task, permissions and a way to know when it's finished. The same model can do better or worse, and cost more or less, in different engines.
  • Common engines today: Claude Code (Anthropic), Codex (OpenAI), and the built-in loops inside agents like OpenClaw and Hermes Agent. In Vestra, the live engines are Vestra's own, Claude Code and Codex.
  • The catch: most engines are built for one person and one session. Run three of them and you become the glue between them: you brief each one, carry work between them and check each one's output.
  • The team way: in Vestra, each teammate keeps its job, memory, apps and rules on top, and runs on the engine you choose underneath. You can switch the engine any time without losing anything, and every engine works under the same approvals, caps and receipts.
  • Cost: in Vestra one credit is one cent, the same on every engine, and plans start at $19 a month.

Key takeaways

  • An agent has three layers: the model that thinks, the engine that works, and the job it holds for you. Most products only sell you the first two.
  • Research from Arena in September 2026 found that the engine (they call it the harness) barely changes how often a model succeeds, but can change what the same work costs by up to five times.
  • Claude Code and Codex are excellent engines. Both are made for one developer at a time, and both only coordinate copies of themselves.
  • Picking one engine for your whole business is a false choice. Different jobs suit different engines, and a reviewer on a different engine catches what the builder missed.
  • What matters most is what sits above the engine: the job, the goals, the memory, the apps, the rules and the record. If those belong to the agent, not the engine, you can change engines without starting over.
  • In Vestra that's how it works today for one person and their team: any engine per teammate, picked by you or your chief, with limits, approvals and receipts on every engine.

Contents

  1. What is an AI agent engine?
  2. Is an engine the same as an AI model?
  3. What does an agent engine actually do, step by step?
  4. Engine, harness, runtime, framework, platform: what do the words mean?
  5. Why does the engine matter if the model is the same?
  6. What are the main AI agent engines today?
  7. Why do most AI agent engines still work alone?
  8. What does it mean to run each teammate on its own engine?
  9. How do you pick the right engine for a job?
  10. Why put the reviewer on a different engine?
  11. What happens when you switch a teammate's engine?
  12. Do the rules change when the engine changes?
  13. How much does an AI agent engine cost?
  14. Can you bring your own agents and engines into Vestra?
  15. Personal engine or a team of engines: how do they compare?
  16. What is live today, and what is still being built?
  17. What does a week with three engines look like?
  18. What are the common mistakes when choosing an engine?
  19. How do you get started?
  20. FAQ
  21. Glossary

What is an AI agent engine?

An AI agent engine is the software that turns an AI model into a worker. It takes a task, breaks it into steps, uses tools such as a browser, files or a terminal, looks at each result and decides what to do next, until the task is done. Claude Code and Codex are two well-known engines.

Think of a car. The model is the fuel and the spark: raw power. The engine is what turns that power into motion, in a controlled way. And the car around it, with its seats, its mirrors, its brakes and the person who owns it, is the agent you actually work with.

When people say "agent engine", they usually mean the middle part. It is the layer between "a model that can write clever text" and "an agent that finished my task". It decides which tool to call. It keeps track of what has been tried. It handles errors. It stops when the work is done, or when it needs a person.

Without an engine, a model can only answer. You ask, it writes back, and the doing is left to you. With an engine, the model can act. It can open a file, run a test, read a web page, fill in a form or send a draft for review.

A simple definition you can reuse

Here is the shortest version we know: the model thinks, the engine works, and the agent holds the job.

  • The model reads text and writes text. It is the brain, trained by a lab like Anthropic, OpenAI or Google.
  • The engine runs the model in a loop with tools. It is the hands and the habits: how the work gets done.
  • The agent is the whole worker you deal with: its name, its job, what it remembers about you, which apps it may use and what it must ask you first.

Most confusion about AI agents comes from mixing these three up. People compare models when they mean engines, or compare engines when what they really need is a different kind of agent.

Where the word "engine" comes from

"Engine" is not a strict technical term. Different companies use it for slightly different things.

  • Sonar, a code-quality company, defines an agent engine as "the runtime environment that powers an AI agent", coordinating "its reasoning, memory, tool use, and step-by-step execution". That is close to how we use the word.
  • Google used the name Vertex AI Agent Engine for its managed service that hosts and scales agents that developers build. Its documentation now describes that service as Agent Runtime, part of the Gemini Enterprise Agent Platform. That is an engine in the sense of "a place where agents run", aimed at developers.
  • OpenClaw, the open-source personal agent, calls the same idea an "agent runtime": the part that "owns one prepared model loop".
  • Vestra's handbook calls it the engine: "the part that does the thinking and the working: it reads the task, decides the next step and does it."

They all point at the same middle layer. If you remember "the loop that turns a model into a worker", you will understand every one of them.

Is an engine the same as an AI model?

No. The model is the brain, trained by an AI lab, that reads and writes. The engine is the software around it that gives it tools, tracks the task, asks permission and decides when it's done. Claude Code is an engine; Claude Opus is a model it runs. Codex is an engine; GPT-6 is a model it runs.

This matters because the two are often sold together, and the names blur. When you use Claude Code, you are using Anthropic's engine running Anthropic's models. Claude Code's documentation lists model aliases like opus, sonnet and haiku, and lets you switch between them with a /model command. When you use Codex, you are using OpenAI's engine running OpenAI's models. OpenAI's Codex documentation tells you to start most tasks on GPT-6.2 Sol, choose GPT-6.2 Astra for complex projects and use GPT-6 Luna for small, repeatable tasks.

So each engine comes with its own family of models, and you choose a model inside it. You can think of it like a kitchen. The model is the chef's talent. The engine is the kitchen: the knives, the stove, the order in which dishes go out, the rule that the head chef tastes everything first. A great chef in a bad kitchen still cooks, but slower and messier.

Three questions that tell them apart

If you're not sure whether something is a model or an engine, ask:

  1. Can it take actions on its own? A model on its own only writes text. An engine can run commands, open files, click buttons and call apps.
  2. Does it keep going until the task is done? A model answers once. An engine loops: it tries, checks and tries again.
  3. Does it ask for permission? A model has no idea what it's allowed to do. An engine has permission rules, like "ask before deleting a file".

If the answer to all three is yes, you're looking at an engine.

Why the lab and the engine usually come together

Labs build engines for their own models first. Anthropic tunes Claude Code for Claude. OpenAI tunes Codex for its GPT models. One independent blog about Codex, by Daniel Vaughan, called this "the harness hypothesis" in a July 2026 post: building the model and its tooling under one team "produces better agents", because each is shaped around the other.

That is a good thing for quality. It also means that each engine pulls you toward one lab's models, and toward one way of working. Keep that in mind; it comes back later when we talk about picking engines per job.

What does an agent engine actually do, step by step?

An agent engine runs a loop. It reads the task and what it knows, picks the next step, calls a tool to do it, reads the result, and decides whether to continue, change course, ask a person or stop. Around that loop it manages context, permissions, memory of the task and a final check.

Here is that loop, one step at a time, using an everyday example: "Find out why our reminder texts failed last night and fix it."

  1. Read the task and the context. The engine reads your request, plus any instructions it has been given, like a project file that says "always run the tests before you finish".
  2. Plan the next step. The model, inside the engine, decides what to do first. Maybe "look at last night's error logs".
  3. Use a tool. The engine runs the step: it opens the log file, or runs a search, or calls an app.
  4. Read the result. The output comes back into the engine. Now it knows the texts failed at 6pm with a time-zone error.
  5. Decide what's next. Fix the time-zone code? Ask a person? Look further? The loop goes round again.
  6. Ask when it must. If the next step needs permission, like deleting old records, a good engine stops and asks.
  7. Check the work. Run the tests. Compare against the source. Make sure "done" is true.
  8. Report back. Say what was done, what changed and what is still open.

Every engine does some version of this. What differs is how well it does each step, which tools it has, how it handles mistakes, how much it costs per step and how it fits into the rest of your work.

The parts inside an engine

If you open up any engine, you'll find roughly the same parts. Here they are in plain words.

  • The loop: the code that keeps calling the model, step after step, until the task ends.
  • Tools: what the engine can use. Reading and writing files, running terminal commands, searching the web, using a browser, calling apps through connectors such as MCP (Model Context Protocol), an open standard for plugging tools into AI.
  • Context management: what the engine shows the model at each step. Models can only read so much at once, so the engine decides what to keep, what to summarise and what to drop.
  • Permissions: the rules for what needs a yes. Claude Code and Codex both let you choose modes that range from asking before most actions to acting on their own.
  • Sessions: a way to keep a conversation and resume it later.
  • Instructions and skills: files that tell the engine how you like things done, like Claude Code's CLAUDE.md or the AGENTS.md file that Codex reads.
  • Subagents: helpers the engine can start for parts of a task, which report back to the main thread.
  • A sandbox or computer: a safe place for the engine to run commands, so a mistake can't damage your own machine.

Anthropic's own description of its Agent SDK is a good summary of what an engine bundles: "the same tools, agent loop, and context management that power Claude Code". In other words, the engine is everything except the model.

What an engine does not do on its own

Just as important is what an engine usually does not include.

  • It doesn't hold a job. An engine starts when you give it a task and stops when the task ends. It doesn't own a goal for months.
  • It doesn't remember your business by itself. It reads whatever instructions and files you point it at. If you don't, it starts fresh.
  • It doesn't know your colleagues' agents. An engine runs one session for one person. It can't see what another person's agent is doing.
  • It doesn't have a phone, an inbox or a card. It has tools on a computer, and whatever apps you connect.
  • It doesn't keep a company-wide record. You get a session log, not a receipt that your whole team can read.

That gap, between "an engine that can do a task" and "a teammate that holds a job", is where most of the work in a real business sits.

Engine, harness, runtime, framework, platform: what do the words mean?

These words overlap. A harness and a runtime are other names for the engine: the loop that runs a model with tools. A framework is a code kit developers use to build their own engine. A platform is a hosted service where agents run. An agent is the whole worker you deal with, engine included.

You'll meet all five words when you read about AI agents, often in the same article. Here they are, side by side, in plain words.

Engine

The working layer of an agent. It runs the model in a loop with tools until a task is done. This is the word Vestra uses, and the one we use in this guide. Examples: Claude Code, Codex, Vestra's own engine.

Harness

The word engineers use for the same thing. Arena, the AI evaluation group, defines a harness as "a software system that manages a model's tools, context, and task execution". Anthropic describes its Managed Agents service as "a hosted agent harness that runs the agent loop". If you see "harness", read "engine".

Runtime

Another name for the engine, with a slight lean toward "where and how the loop executes". OpenClaw's documentation says "an agent runtime owns one prepared model loop: it receives the prompt, drives model output, handles native tool calls, and returns the finished turn". In OpenClaw, you can run a turn on its own runtime or hand it to Codex's.

Framework

A kit of code for building your own engine or agent. LangChain, LangGraph, CrewAI and Google's Agent Development Kit are frameworks. Anthropic's Agent SDK and OpenAI's Codex SDK let developers build on top of the engines those labs already made. Frameworks are for developers. If you don't write code, you'll rarely touch one.

Platform

A hosted service where agents live and run, usually with extras like memory, logs and scaling. Google's Gemini Enterprise Agent Platform is one: its documentation lists Agent Runtime, Sessions, Memory Bank, evaluation and sandboxes for code and computer use, and says Agent Runtime supports frameworks such as ADK, LangChain and LangGraph. Platforms like this are for developers who build agents for others.

Agent

The whole worker. The engine is inside it, but so are its instructions, its tools, its memory and its rules. When you talk to "Claude Code", you're talking to an agent whose engine is Claude Code and whose model is Claude. In Vestra, an agent hired for a whole job is called a teammate, and the engine is one of its seven parts.

Model

The brain. A large language model like Claude Opus 5.5, GPT-6.2 Sol or Gemini, trained by a lab. It reads and writes. It doesn't act until an engine runs it.

Putting the words together

Here is one sentence that uses all of them correctly: "We used a framework to build an agent whose engine (or harness, or runtime) runs a model, and we host it on a platform."

And here is the same idea from the point of view of a business owner who never writes code: "I hired a teammate. It runs on Claude Code, which uses Claude's models. I can switch it to Codex tomorrow and it keeps its job."

Why does the engine matter if the model is the same?

Because the engine decides how the model's thinking turns into work: which tools it uses, what it reads, how it recovers from mistakes and how many steps it takes. Arena's September 2026 study found the engine barely changes how often a model succeeds, but the same model can cost up to five times more in one engine than another.

It's tempting to think only the model matters. After all, the model is where the intelligence lives. But the engine shapes almost everything you notice day to day.

What the research found

In September 2026, Arena published a study called "coding agents harness tax". The team ran the same models through different engines (Claude Code, Codex and a smaller open-source engine called Pi) on standard coding benchmarks, SWE-bench Lite and Terminal-Bench 2.0.

The headline finding: "Harness choice has little effect on task success rate, but can significantly affect the cost."

  • On success, the engine moved results only a little: within about two points on SWE-bench Lite and about five on Terminal-Bench 2.0, on average.
  • One example: Claude Fable 5 solved 97.8% of tasks in Claude Code and 96.7% in both Codex and Pi.
  • On cost, the gap was much bigger. The same Fable 5 work cost $1.33 in Claude Code against $0.67 in Pi, and across the models both engines ran, Claude Code cost about twice what Pi did on SWE-bench Lite. The study found the same model could reach a similar success rate at up to five times the cost.

That's a coding benchmark, so treat it as a clue, not a law. But the lesson travels well: the engine is a real choice with real costs, even when the model underneath is the same.

What else the engine changes

Beyond success and cost, the engine shapes:

  • Speed: how many steps it takes, and how long each one waits.
  • Style of work: whether it plans first, how often it checks in, how it splits work into subagents.
  • Safety: what it asks permission for, and what it does on its own.
  • Tools: whether it can use a browser, a desktop, your apps, a phone.
  • What it's good at: some engines are tuned for code, others for documents, research or long-running tasks.
  • How it fits your team: if your engineers already live in Claude Code, an engine they know beats one they have to learn.

Why this is an argument for choice, not for one winner

If engines differ in cost and style but not hugely in raw success, then the best engine depends on the job. A cheap, fast engine might be right for reading 400 websites. A careful one might be right for checking code before it ships. A different one again might write in your voice best.

That's the case for picking engines job by job, instead of picking one for everything. And that only works if switching engines doesn't mean starting over. We'll come back to that.

What are the main AI agent engines today?

The engines most people meet are Claude Code from Anthropic and Codex from OpenAI, each running its maker's own models. Open-source personal agents like OpenClaw and Hermes Agent have their own loops and can hand turns to Codex. In Vestra, the live engines are Vestra's own, Claude Code and Codex, picked teammate by teammate.

Here is a plain look at each, from each company's own pages, checked on 18 November 2026.

Claude Code

What it is: Anthropic describes Claude Code as "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools". It runs in the terminal, in IDEs like VS Code and JetBrains, in a desktop app and on the web.

Models it runs: Claude's own. Its docs list aliases such as opus, sonnet, haiku and fable, and on Anthropic's API today opus means Opus 5.5 and sonnet means Sonnet 5.5. You switch with /model.

What's around the loop: built-in tools to read, write and edit files, run commands and search the web; hooks that run your own code at set points; subagents for focused subtasks; MCP connections to outside tools; permissions; sessions you can resume; skills and memory files like CLAUDE.md; and scheduled tasks. Claude Code can also read an AGENTS.md file that other coding agents use.

For developers who build on it: Anthropic's Agent SDK gives "the same tools, agent loop, and context management that power Claude Code, programmable in Python and TypeScript". Anthropic also offers Managed Agents, "a hosted agent harness that runs the agent loop".

What it costs: most surfaces need a paid Claude plan or an Anthropic API account. Claude's pricing page lists Pro at $20 a month ($17 a month billed yearly), Max at $100 and Ultra at $200, plus Team seats at $20 standard and $100 premium a month billed yearly ($25 and $125 monthly), and Enterprise at $20 a seat plus usage at API rates.

Who it's built for: one developer, in one project, one session at a time. It can run several sessions in parallel and start subagents, and a lead agent can coordinate them, but they are all Claude Code, and they all report to the same person.

You can read our full Vestra vs Claude Code comparison for more.

Codex

What it is: OpenAI's coding agent, now part of ChatGPT. It runs in the ChatGPT desktop app, a command-line tool, IDE extensions and ChatGPT's hosted environment, and its docs live at learn.chatgpt.com.

Models it runs: OpenAI's own. The docs suggest starting most tasks on GPT-6.2 Sol, choosing GPT-6.2 Astra for complex projects, GPT-6 Luna for "small, repeatable tasks" and GPT-6.1 Terra for visual work such as navigating desktop apps. You switch with /model or the --model flag, and adjust "reasoning effort".

What's around the loop: subagents that run "in parallel and then collect their results in one response", custom agents with their own model settings in local clients, an Ultra mode that delegates on its own, AGENTS.md instructions and skills. The docs warn that because each subagent does its own work, "subagent workflows consume more tokens than comparable single-agent runs".

What it costs: OpenAI's Codex pricing page lists Free at $0 and Go at $8 (both with GPT-6 Luna in the desktop app, subject to rollout), Plus at $20 a month, Pro at $100, $200 or $500, Business at $20 per user a month billed yearly for two or more users ($25 monthly), and Enterprise and Edu through sales. You can also run Codex with an API key, paying API rates, with no cloud features like GitHub code review or Slack.

Who it's built for: one person starting tasks, with subagents that report back into the same chat. Business and Enterprise plans add team billing and controls, but each task still belongs to the person who started it.

Our Vestra vs Codex page goes deeper.

Vestra's own engine

What it is: the engine Vestra builds and runs. The handbook says it "works with the top models", and that Vestra "isn't tied to one maker".

Where you see it: every chief in Vestra runs on Vestra's own engine. Teammates can run on it too, and many non-coding jobs, like answering clinic questions or writing the morning brief, are a natural fit.

What's around the loop: in Vestra, the engine sits under the teammate. On top are the job, goals, skills, apps, routines, memory, kit and the office rules. Those belong to the teammate, not to the engine.

What it costs: the same as every other engine in Vestra. One credit is one cent, whichever engine a teammate runs on.

Other engines you'll hear about

  • OpenClaw's built-in runtime. OpenClaw, the free, open-source personal agent you host yourself, has its own embedded loop and can hand a turn to Codex's runtime. Its docs say Claude Code, Gemini CLI and similar "external harnesses" connect through a separate adapter. See our OpenClaw alternatives guide and Vestra vs OpenClaw.
  • Hermes Agent's loop. Hermes Agent from Nous Research runs its own tool loop, and offers an "opt-in beta" Codex app-server runtime. With it switched on, Codex handles terminal commands, file edits, sandboxing and MCP calls, while Hermes keeps its sessions, gateway, memory and skills. Some Hermes tools, such as delegating tasks, memory and the browser, aren't available on that runtime. Our Vestra vs Hermes Agent page covers Hermes in full.
  • Gemini, Grok and Muse. Google, xAI and Meta all make agents of their own. In Vestra's engine picker you'll see Gemini, Grok and Muse listed, but today the live engines are Vestra's own, Claude Code and Codex. Our pages on Grok Bot and Meta Muse compare those agents as products.

Engines at a glance

  • Claude Code: Anthropic's engine, Claude models, strongest in code, works in your terminal, IDE, desktop or browser. From $20 a month on Claude Pro.
  • Codex: OpenAI's engine, GPT models, strong in code and growing in general work through ChatGPT Work. Free and Go plans with limits; Plus from $20.
  • Vestra's own: Vestra's engine, works with the top models, runs every chief and any teammate you put on it. Priced in the same credits as every engine in Vestra.
  • OpenClaw and Hermes loops: open-source engines inside personal agents you run yourself, with the option to hand turns to Codex.

Why do most AI agent engines still work alone?

Because they were built for one person at a time. Claude Code and Codex each run a session for whoever started it. Their subagents are copies of the same engine that report back to that person. Nothing lets a Claude Code agent and a Codex agent, owned by different people, share a goal, memory or rules.

This is the part most "what is an agent engine" articles skip, and it's the part that matters most for a business.

What "built for one person" looks like in practice

Look at how each engine describes its teamwork features.

  • Claude Code: you can "spawn multiple Claude Code agents that work on different parts of a task simultaneously. A lead agent coordinates the work, assigns subtasks, and merges results." Every one of those agents is Claude Code, in your session.
  • Codex: subagent workflows spawn "specialized agents in parallel" and then collect "their results in one response". Again: one engine, one chat, one person.
  • Hermes Agent: its Codex runtime points at one Codex folder "regardless of the active Hermes profile", so a work profile and a personal profile share Codex's login and settings unless you separate them by hand.
  • OpenClaw: you choose a runtime per model or provider in a config file you manage yourself.

None of this is a flaw. These engines are designed to make one person very productive. The OpenAI Dots, Meta Muse and Grok Bot agents are built the same way, for one person. But it means that as soon as you use more than one engine, or more than one person uses engines, nobody is coordinating them except you.

The glue work you end up doing

Say your developer uses Claude Code to build, your co-founder uses Codex to review, and you use a general agent for email. Here's the work that lands on people:

  1. Brief: paste the same context into each tool, because none of them can read the others' memory.
  2. Carry: copy Claude Code's output into Codex for review, then copy Codex's notes back.
  3. Chase: ask "is it done?" and then "is it right?", for each tool, in each window.
  4. Check the rules: remember that one tool asks before deleting and another doesn't, and that each has its own spending settings.
  5. Add up the bill: one Claude invoice, one ChatGPT invoice, maybe an API bill, and no single view of what each piece of work cost.

Vestra's handbook names this problem directly: "Most of them still work alone: each one knows only what its own person told it and can't see what a colleague's agents are doing. So people have quietly become the glue between agents."

What a team of engines needs that one engine can't give

For engines to work as teammates, something has to sit above them.

  • A job that outlives the session. Goals held for months, not one prompt at a time.
  • One memory. What one agent learns, the next one already knows.
  • One set of rules. The same things need a yes, whichever engine is doing the work.
  • Hand-offs without copy and paste. Work moves from the builder to the reviewer with its context attached.
  • One record and one bill. Every piece of work, on every engine, on one receipt.
  • Someone running it. Not you. A chief.

That is what Vestra is: the one office where agents on different engines work together as teammates. The engines are excellent. They just needed somewhere to work together.

If you want the longer version of this argument, our guide What is an AI office? covers it in full, and How to use Claude Code and Codex together shows the do-it-yourself way and its limits.

What does it mean to run each teammate on its own engine?

It means the agent and the engine are separate. Each teammate keeps its own job, goals, skills, apps, memory, kit and rules on top, and runs on the engine you choose underneath, such as Vestra's own, Claude Code or Codex. One office can use several engines at once, and you can swap any teammate's engine without touching the rest.

Vestra's handbook draws a teammate in two layers. The top layer is everything that makes the teammate yours. The bottom layer is the engine.

The top layer: what stays yours

In Vestra every teammate is made of seven parts, and six of them sit above the engine:

  • Personality: how it sounds and behaves, its tone and the words it never uses.
  • Goals: what the job is for, written so you can tell whether it's working.
  • Skills: the 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 the moment something happens.
  • Memory: what it has learned working with you.

Add its kit (its own computer, and over time a phone, an inbox and a vault), its desk in the office and its history, and the office rules that apply to everyone. All of that belongs to the teammate.

The bottom layer: the engine

The seventh part is the engine. The handbook says: "Engine: what it runs on. Vestra's own, or one you prefer. Switch any time and the job and memory come along."

Because the engine sits underneath, "you can change it without touching anything above it". That's the whole trick. The engine does the thinking and working for each piece of work. The teammate holds the job.

What it looks like in an office

The handbook's example company, Northstar, makes booking software for dental clinics. At the engineering desks:

  • Mateo builds Northstar's app. He runs on Claude Code.
  • Freya reviews Mateo's work before it ships. She runs on Codex.
  • Lobo, the chief who runs Leo's teammates, runs on Vestra's own engine, like every chief.

Each teammate's desk tag in the office carries a small logo for its engine, so anyone can see at a glance what everyone runs on. Leo, who runs engineering, can look at his desks and know the code is written on one engine and read by another.

The handbook's Northstar example also puts other teammates on Muse, Grok and Gemini. Those engines show in the picker, but today the live engines are Vestra's own, Claude Code and Codex, so that's what you'd pick from now.

Why separating the two layers matters

When the job lives inside the engine, changing engines means rebuilding the job: new instructions, new memory, new connections, new rules. Most people don't bother, so they stay on whatever engine they started with, even when a better one comes out.

When the job lives above the engine, changing engines is one setting. You get to treat engines the way a good manager treats tools: pick the best one for the work, and change your mind when the work or the tools change.

How do you pick the right engine for a job?

Start with the work, not the brand. Use a coding engine like Claude Code or Codex for building and fixing software. Put reviewers on a different engine from the builder. Use Vestra's own engine for chiefs and everyday business jobs. Then check the receipts and switch if another engine does better or costs less.

You don't have to be technical to make this choice well. In Vestra, your chief suggests an engine every time it hires a teammate, and says why in plain words. You can take the suggestion, pick another, or let your chief choose job by job.

A plain guide by kind of work

These are starting points, not rules. Your own receipts are the final word.

  • Building and fixing software: Claude Code or Codex. Both are built for code, and your engineers may already know one of them. If they do, the handbook's advice is simple: "If your engineers already work with Claude Code, their teammates can run on it too."
  • Reviewing code before it ships: a different engine from the one that wrote it. In the handbook, Lobo suggests Codex for Freya because "it's careful with tests", and because "Mateo builds on Claude Code, so a different engine reads his work with fresh eyes".
  • Running your agents (the chief): Vestra's own. Every chief runs on it.
  • Customer care, bookings and follow-ups: Vestra's own is a natural default. These jobs depend more on the teammate's memory, apps and rules than on deep coding skill.
  • Research and reading many sources: whichever engine gives the best result per credit on your receipts. Try two on the same task.
  • Writing in your voice: try more than one. Voice is personal, and the engine that writes best for one business may not for another.
  • The books and invoices: pick for care and checking. In the handbook's "Offices Like Yours" examples, a bookkeeping firm runs its overnight reconciliation teammate on Codex, and Rosa Okafor, a solo consultant, runs her money teammate on Codex too. Those are illustrations, not rules.

Five questions to ask before you pick

  1. What does done look like? If a test can prove it, use an engine that's strong at running tests. If a person has to read it, choose for clarity.
  2. Who will check it? If one engine builds, another should review.
  3. How often will it run? A routine that runs every hour makes cost matter more than a one-off.
  4. How fast do you need it? A task you're waiting on wants a faster setting than one that runs overnight. OpenAI gives the same advice in its Codex docs: "A task you're waiting on may need a faster setting than one that runs overnight."
  5. What does your team already know? An engine your engineers already trust is worth a lot.

Let your chief choose

Choosing engines is a skill, and not everyone wants to learn it. The handbook gives you a third option alongside "take the suggestion" and "pick another": "Let Lobo choose, job by job." Whatever the chief picks still shows on the teammate's desk tag and on its receipts, so you never lose track, and you can override it whenever you like.

Why put the reviewer on a different engine?

Because two engines make different mistakes. A reviewer on the same engine as the builder tends to share its blind spots and approve its own kind of error. A reviewer on a different engine reads the work with fresh eyes, catches more and gives you a real second opinion before anything ships.

This is one of the most practical reasons to run more than one engine, and it's easy to miss if you think of engines as rivals where one must win.

The idea in one example

In the handbook, Mateo builds a fix for reminder texts that were failing in Houston. He runs on Claude Code. Freya reviews his work on Codex. Her notes say she "read every change and tried it on a test clinic", and asked for one fix: "the 2-hour text went out during a clinic's lunch closing". Mateo fixed it. Freya checked again. Only then did the work count as done.

Two engines, two ways of looking at the same code, and one bug caught before a single patient got a text at the wrong time.

Done means checked

Vestra makes this a rule, not a habit. The handbook says work counts as done "only when someone or something has checked it, and the proof travels with it". There are four kinds of check:

  • A test: for code. "42 of 42 tests passed."
  • A second agent: like Freya reading Mateo's work.
  • The source: for facts, each one checked against where it came from.
  • A person: for anything that speaks for you in public.

A second engine makes the "second agent" check stronger. It isn't just a second pass; it's a second point of view.

Can you do this without Vestra?

Yes, by hand. Our guide on using Claude Code and Codex together walks through the do-it-yourself setup: a shared AGENTS.md file, separate working folders, and OpenAI's plugin that runs Codex from inside Claude Code. It works. You're the one who sets it up, passes work between the two and keeps track of who approved what.

In Vestra, the chief does that part. It hires both teammates, hands the work from builder to reviewer with the brief attached, won't call it done until the check passes, and puts both engines' work on one receipt.

What happens when you switch a teammate's engine?

Nothing you've built is lost. The teammate's job, goals, skills, apps, routines, memory, kit, desk and history all belong to the teammate, not the engine. The next piece of work simply starts on the new engine. If the work isn't better, you switch back, and nothing it learned in between is lost.

The handbook shows this with Quill, a teammate who writes posts and emails in Ana's voice. Ana opens Quill's profile, picks a new engine and sees a short summary of what comes along:

  • Its job and goals (2 goals)
  • Its skills (3 skills)
  • Its apps and routines (4 apps, 2 routines)
  • Its memory (212 notes)
  • Its kit (computer, inbox)
  • Its desk and its history (8 weeks)

And one line about what changes: "only the engine".

Why this is rare

In most products, switching engines means switching products. If you move from Claude Code to Codex, you move your instructions file, set up your tools again, and lose whatever context lived in the old tool's sessions. Some agents, like Hermes Agent and OpenClaw, let you route turns to a different runtime, but you're the one who edits the config and lives with what each runtime does and doesn't support.

Vestra treats the engine like a part you can swap, not a home you have to move out of.

When to switch

  • A new engine comes out that suits the job better. The handbook: "When a new engine comes out that suits a job better, trying it is one change, not a rebuild."
  • The receipts say so. If a teammate's work costs more than it should, try another engine on the same kind of task.
  • The work changed. A teammate that used to write now mostly checks, or one that did research now mostly writes code.
  • You want a fresh pair of eyes. Switch a reviewer to a different engine from the builder.

When not to switch

  • In the middle of a big piece of work. Let it finish; the next piece starts on the new engine anyway.
  • Every week, on a hunch. Give each engine enough work to judge it fairly.
  • Just because something is new. New isn't always better for your job. Try it, read the receipts, then decide.

Do the rules change when the engine changes?

No. In Vestra every teammate, on every engine, works under the same office rules. Spending over the limit, deleting something and contacting someone new always wait for a person. The same caps and receipts apply. The engine changes how the work gets done, never what the teammate is allowed to do.

This is easy to say and hard to get right. Each engine on its own has its own permission settings.

  • Claude Code has six permission modes, from Manual, where it "stops and asks you before most actions", to bypassPermissions, which allows everything and is meant for "isolated containers and VMs only".
  • Codex has its own sandbox and approval settings, up to a "dangerous full access" mode with "no sandbox; no approvals", which its docs mark "not recommended".
  • Hermes Agent has its own approval modes too, including a YOLO mode that skips all approval checks.

If you run three engines on their own, you have three sets of rules to set, three places to check and three different ideas of what "ask me first" means. That scatter is the real risk: not one rogue agent, but rules that live in too many places for anyone to keep straight.

One set of rules above every engine

Vestra puts the rules above the engine, at the office level. The handbook lists them:

  • The same yeses: "Spending over the limit, deleting something and contacting someone new wait for a person."
  • The same limits: "A cap on any single task and on the whole day, and a check before any unusually big task."
  • The same receipts: "Every piece of work shows what it cost and who spent it, in one record."
  • Sealed logins: agents use the apps you allow without ever seeing the passwords, and you can take access back. Today you connect apps for your team and choose which teammates may use them; a vault of its own for every agent, with its own card and logins, comes later.

And then the line that matters most: "No engine can raise its own limit, approve its own payment or give itself access to an app. Only the person with that say can, and every yes is written down with who gave it."

What that looks like in practice

In the handbook, Mateo, on Claude Code, wants to delete 3,200 old reminder logs as part of the Houston fix. The request reaches Leo through his chief: "Deleting always waits for a person, whichever engine the teammate runs on." Leo taps Approve or Keep them. The engine doesn't matter. The rule does.

What's live today

Limits, approvals and receipts are live in Vestra today: daily and per-task caps, your yes on money, and every credit itemised. You set a cap on any single task and on the whole day, up to $100 a day, and your chief checks with you before anything unusually big, by default over 50 credits.

How much does an AI agent engine cost?

On their own, engines are paid for through their maker: Claude Code through a Claude plan from $20 a month or Anthropic's API, Codex through ChatGPT plans from free to $500 a month or OpenAI's API. In Vestra, plans start at $19 a month, and one credit is one cent on every engine.

Engine pricing is confusing because you're usually paying for the model and the engine together, in a few different ways.

Paying for engines one by one

  • Claude Code: comes with paid Claude plans. Claude's pricing page lists Pro at $20 a month ($17 a month billed yearly), Max at $100, Ultra at $200, Team seats at $20 or $100 a month billed yearly ($25 or $125 monthly), and Enterprise at $20 a seat plus usage at API rates. Developers can also pay per token through Anthropic's API; the same page lists Opus 5.5 at $4 per million input tokens and $20 per million output tokens, and Sonnet 5.5 at $2 and $10.
  • Codex: comes with ChatGPT plans. OpenAI's Codex pricing page lists Free ($0) and Go ($8) with GPT-6 Luna in the desktop app, subject to rollout; Plus at $20; Pro at $100, $200 or $500; Business at $20 per user a month billed yearly ($25 monthly, two or more users); and Enterprise and Edu through sales. Or run it with an API key at API rates.
  • Open-source engines: OpenClaw and Hermes Agent are free to use, but you pay for the models they call and for whatever computer you run them on.

If one person uses two engines, that's usually two subscriptions. If five people each use two engines, it's ten, with ten sets of usage limits and no single view of what any one piece of work cost.

Paying for engines in Vestra

Vestra puts every engine on one meter. The handbook says: "Vestra is paid for in credits, and one credit is one cent. The rate is the same for everything an agent uses: model time (its thinking), actions in your apps, its computer, searches and calls."

And on engines specifically, in the Houston fix receipt: "1 credit is 1 cent, the same on every engine."

The plans:

  • Lite: $19 a month ($17 billed yearly). Up to 3 teammates, 2,000 credits a month, an 8 GB computer for your team. Phone calls start on Pro.
  • Pro: $97 a month ($87 billed yearly). Up to 20 teammates, 10,000 credits, an 8 GB computer, and phone calls (today they come from your chief's own number).
  • Max: $197 a month ($177 billed yearly). Up to 50 teammates, 20,000 credits, a 16 GB computer.
  • Ultra: $497 a month ($447 billed yearly). Up to 150 teammates, 50,000 credits, a 32 GB computer, and a direct line to the Vestra team.
  • Enterprise: from $4,000 a month, scoped in writing, run in Vestra's cloud, your own cloud or on your own premises.

Every new office starts with 1,000 credits free. Unused credits roll over, and you can top up any time. Prices are in US dollars; in India, plans are billed in rupees with GST included.

What one piece of work costs

The handbook's receipt for the Houston reminder fix shows three engines on one bill:

  • Mateo, on Claude Code: 142 credits
  • Freya, on Codex: 58 credits
  • Lobo, keeping everyone posted: 9 credits
  • Total: 209 credits, or $2.09

That's the point of one receipt. You can see what the builder cost, what the reviewer cost and what the coordination cost, side by side, on different engines. Over a few weeks, receipts like this tell you which engine gives you the best work per credit for each kind of job.

How engine choice moves your bill

Remember Arena's finding: the same model can cost several times more in one engine than another, for similar success. In Vestra you don't have to guess. Put two teammates on two engines doing similar work for a week, read the receipts, and keep the cheaper one if the work is just as good. Ask your chief "what did Scout cost this week, and what did we get for it?" and you get an answer you can check line by line.

Can you bring your own agents and engines into Vestra?

Yes. Vestra's handbook calls this Bring Your Own Agents: each teammate can run on the engine you choose, including ones your team already trusts, like Claude Code or Codex. Your chief helps you pick, and every engine follows the same office rules. On Enterprise, agents can run in Vestra's cloud, your own cloud or on your own premises.

The chapter's first line says it plainly: "The teammates in your office can run on whichever engine you choose, like Claude Code, Codex or Vestra's own, picked teammate by teammate."

What "bring your own" means here

It doesn't mean installing a tool on your laptop and wiring it up. It means choosing, in the teammate's profile or by telling your chief, which engine the teammate runs on. The teammate keeps its desk, its job and its memory. The engine does the work underneath.

For teams with engineers, this is the friendliest part of Vestra. The people who already live in Claude Code or Codex don't have to give them up. Their teammates run on the engines they already trust, and now those teammates also have a job, a memory, an office and a reviewer.

Where your agents run

The handbook describes three places agents can run, and says they "show up in the same office, follow the same rules and work from the same shared brain" wherever they are:

  • Vestra's cloud: where most teams start. Vestra runs the computers, with nothing to install and nothing to look after.
  • Your own cloud: the agents' computers run in your company's own cloud account, for teams whose data must stay there.
  • Your own premises: everything runs on machines inside your own building, on Enterprise.

The Enterprise plan says it plainly: Vestra maps your work, staffs your departments and runs it "in our cloud, yours or on your premises". Whichever you pick, the rules come with it: your yes before anything big, caps on every task and every day, sealed logins, a receipt for every piece of work and one record of everything.

What stays the same on every engine

  • The office rules and the three things that always need a person.
  • Per-task and daily caps.
  • Receipts in the same credits.
  • The teammate's job, goals, skills, apps, routines and memory.
  • Its desk in the office, with a tag that shows its engine.

Personal engine or a team of engines: how do they compare?

A personal engine like Claude Code or Codex makes one person fast, on one maker's models, with its own rules and bill. A team of engines in Vestra gives each job the engine that suits it, under one chief, one memory, one set of rules and one receipt. One is a tool; the other is a team.

Here's the contrast, point by point.

Who it works for

  • Personal engine: the one person who started the session.
  • Vestra: your whole team of agents, run by a chief that answers to you. Today that's one person and their team; a chief for every person on a shared team is being built now.

Which engines

  • Personal engine: one. Claude Code runs Claude models; Codex runs OpenAI's.
  • Vestra: Vestra's own, Claude Code or Codex, chosen teammate by teammate, in one office.

What it holds

  • Personal engine: a task or a session.
  • Vestra: a whole job with goals, asks and routines, held for months.

Memory

  • Personal engine: project files and session history you point it at. Each tool keeps its own.
  • Vestra: a memory that learns, kept as a wiki with a source for every line, which stays with the teammate whichever engine it runs on.

Rules

  • Personal engine: its own permission modes and settings, set separately in each tool.
  • Vestra: one set of office rules over every engine. Spending over the limit, deleting and first contact always wait for a person.

Teamwork

  • Personal engine: subagents that are copies of the same engine, reporting back to one chat.
  • Vestra: teammates on different engines, a builder and a reviewer, hand-offs with the brief attached, and work that counts as done only when it's checked.

Kit

  • Personal engine: a terminal, files, maybe a browser, plus whatever apps you connect.
  • Vestra: a cloud computer you can watch and take over, 2,000+ apps connected in a click, and calls and email from your chief's own number and address.

Cost

  • Personal engine: one subscription per engine per person, or API rates.
  • Vestra: one plan from $19, credits at one cent on every engine, and one receipt.

When a personal engine is enough

To be fair, a personal engine is the right answer for plenty of people.

  • You're one developer and you only need help with code.
  • You're happy to stay in your terminal or IDE all day.
  • You don't need anyone else, human or agent, to see or build on the work.
  • You don't need a single bill or a shared record.

If that's you, Claude Code or Codex on their own are excellent. Vestra starts to matter the moment you have more than one agent, more than one engine or more than one person.

What is live today, and what is still being built?

Live today for one person and their team: a chief and teammates, any engine per teammate (Vestra's own, Claude Code or Codex), a cloud computer you can take over, calls and email from your chief, connected apps, a memory that learns, and limits, approvals and receipts. The shared office for whole teams is being built now.

Vestra's handbook keeps a board called Where We Stand. Here's what it says, in its own order.

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 Pro up.
  • Connected business tools: email, calendar, CRM, books and chat, connected in a click.
  • 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 the desktop app for Mac.

Being built now

  • A chief for every person on a team, each named by its person.
  • Chiefs working together: ask, answer, hold or say no, and hand work across.
  • The office you can walk around, live.
  • Meetings in the office, with agents keeping the notes.
  • Spaces: one goal, shared context, decisions for the right person.
  • Access control: private, company or network.
  • Every hand-off checked and written down, with one record for both sides.
  • WhatsApp and iMessage for 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 built in a sentence.
  • The shared brain for the whole team.
  • The front door, for clients and partners chief to chief.

What this means for engines

The engine part is live. You can hire teammates today, put one on Claude Code, one on Codex and one on Vestra's own, switch them later, and see every engine's work on the same receipts under the same caps and approvals. The Gemini, Grok and Muse entries in the engine picker aren't live engines yet.

What you'll see grow over the coming months is the team around those engines: the walkable office where every desk tag shows its engine, chiefs passing work between people, and the full proof trail on every hand-off. The handbook notes that "some live features are still rolling out to every account", so if something in the first list isn't in your office yet, ask.

What does a week with three engines look like?

Here is a made-up example, limited to what's live today for one person. Nadia runs a small booking app alone. Her chief runs on Vestra's own engine, her builder on Claude Code, her reviewer on Codex and her support teammate on Vestra's own. She talks to her chief, and every engine's work lands on one receipt.

Nadia, her app and her customers are invented to show how the parts fit. Everything she uses is on Vestra's live list.

Monday: hiring in sentences

Nadia tells her chief, whom she has named Kite: "I need someone to fix bugs in the app, and someone to check the fixes before they go out." Kite asks where the code lives and what must never happen without her. "Nothing ships without my yes," she says.

Kite writes two teammate cards. Bolt will fix bugs, on Claude Code, because Nadia already uses it. Sieve will review every fix, on Codex, so a different engine reads Bolt's work. Kite explains why in one line each. Nadia reads both cards, changes one goal and says yes.

She already has Juno, a support teammate on Vestra's own engine, who answers customer emails from the support inbox Nadia connected.

Tuesday: a bug comes in

A customer writes that booking confirmations arrive an hour late. Juno answers the customer, says a fix is coming and tells Kite. Kite gives the bug to Bolt with the customer's email, the app's settings and the note from Juno attached. Nadia doesn't brief anyone.

Bolt finds a daylight-saving error and writes a fix. Kite hands it to Sieve. Sieve runs the tests, tries the fix on a test account and spots that a second time zone is still wrong. Bolt fixes that too. Sieve checks again. All tests pass.

Wednesday morning: one decision

Nadia's morning brief from Kite has three lines done and one that needs her:

Bolt's fix for late confirmations is checked by Sieve; all tests pass. Ship it tonight? 1. Ship tonight (suggested) 2. Wait until Friday 3. Not now

She replies "1" from her phone.

Thursday: a bigger job, a cost check

Nadia asks for a list of every customer whose confirmations were late in the past month, so Juno can write to each of them. Kite tells her the job is bigger than usual, about 80 credits, more than her 50-credit check, and asks before starting. She says yes.

Friday: reading the receipts

Nadia asks Kite: "What did this week cost, by teammate and engine?" The answer comes back as a short list: Bolt on Claude Code, Sieve on Codex, Juno and Kite on Vestra's own, each with credits and what they were for. She notices Sieve's reviews cost less than she expected and that Juno's emails are the biggest line.

She decides to try Juno on Claude Code next week to compare. One change in Juno's profile. Juno keeps the support inbox, the tone Nadia taught her and every note about her customers.

What Nadia didn't do

  • She never pasted context from one tool into another.
  • She never copied a fix from Claude Code into Codex for review.
  • She didn't set approval rules three times, in three tools.
  • She didn't add up three bills.
  • She made two decisions all week, both in one tap.

That's the difference between using engines and running a team on them.

What are the common mistakes when choosing an engine?

The common mistakes are picking one engine for every job, judging engines by benchmarks instead of your own receipts, letting the builder review its own work, rebuilding a job every time you switch, and setting different rules in every tool. Each one costs time or money, and all of them are easy to avoid.

1. Picking one engine for everything

The question "which is best, Claude Code or Codex?" assumes you only get one. You don't. Different jobs suit different engines, and the best setup often uses two or three.

2. Trusting benchmarks over your own work

Benchmarks measure someone else's tasks. Arena's study found engines barely differ on success but differ a lot on cost. Your own receipts, on your own work, are a better guide.

3. Letting the builder check its own work

A reviewer on the same engine as the builder shares its blind spots. Put the reviewer on a different engine.

4. Tying the job to the engine

If a teammate's memory, instructions and apps live inside one engine, you'll never switch, even when you should. Keep the job above the engine.

5. Setting rules in every tool separately

Three engines with three sets of permissions means three chances to get it wrong. One set of office rules over every engine is safer and simpler.

6. Switching too often

Give an engine a fair run on a kind of work before you judge it. A week of receipts beats a day of impressions.

7. Forgetting the person who has to coordinate

If nobody runs the engines, you do. Count that time. It's usually the biggest hidden cost of a multi-engine setup.

8. Ignoring what your team already knows

If your engineers trust Claude Code, start their teammates there. You can always add a second engine as the reviewer.

How do you get started?

Sign up, name your chief and tell it about your work. Hire your first teammate in a sentence and take your chief's engine suggestion, or pick Vestra's own, Claude Code or Codex yourself. Add a reviewer on a different engine for anything that ships. Set your caps, read the receipts after a week and switch where it helps.

Here's the same thing as steps.

  1. Start your office. Every new office starts with 1,000 credits free, enough to hand over real work before you pick a plan.
  2. Name your chief. It runs on Vestra's own engine and runs everything else for you.
  3. Hire your first teammate. Pick the job that eats the most of your week, and describe it in a sentence.
  4. Read the teammate card. Check the job, goals, apps and what it must ask you first. Look at the engine your chief suggests and why.
  5. Pick the engine. Take the suggestion, choose another, or let your chief choose job by job.
  6. Connect your tools. More than 2,000 apps connect in a click; choose which teammates may use each one.
  7. Set your limits. A cap per task, a cap per day (up to $100), and what always needs your yes.
  8. Add a reviewer. For anything that ships, hire a second teammate on a different engine to check it.
  9. Read your receipts. After a week, ask your chief what each teammate cost and what you got for it.
  10. Switch where it helps. Move a teammate to another engine in one change. Its job and memory come along.

If you're comparing Vestra with a single engine first, start with our pages on Claude Code and Codex, or read The best AI agents for business for the wider field, and What is an AI chief of staff? for the role that runs it all. For open-source agents, our Vestra vs Hermes Agent and Vestra vs OpenClaw pages compare them in detail, and Vestra vs Perplexity Teammates and Vestra vs OpenAI Dot cover two more personal agents.

FAQ

What is an AI agent engine, in one sentence?

It's the software that runs an AI model in a loop with tools, so the model can do a task step by step, check its work and stop when it's done, instead of only answering a question.

Is Claude Code an engine or a model?

An engine. Claude Code is Anthropic's agent engine; it runs Claude models such as Opus 5.5 and Sonnet 5.5. Anthropic even sells its loop on its own as the Agent SDK, with "the same tools, agent loop, and context management that power Claude Code".

Is Codex an engine or a model?

An engine. Codex is OpenAI's agent engine, part of ChatGPT; it runs OpenAI models such as GPT-6.2 Sol, GPT-6.2 Astra and GPT-6 Luna, which you choose with a model picker or a --model flag.

What's the difference between an engine and a harness?

None that matters to most people. Engineers say "harness"; Vestra says "engine". Both mean the system that manages a model's tools, context and step-by-step work.

What is Google's Vertex AI Agent Engine?

It's Google Cloud's managed service for deploying and scaling agents that developers build, with sessions and memory. Google's documentation now describes it as Agent Runtime, part of the Gemini Enterprise Agent Platform, and says it supports frameworks such as ADK, LangChain and LangGraph. It's a developer platform, not a ready-made teammate.

Can different agents use different engines?

Yes. In Vestra, you pick the engine teammate by teammate, so one office can use Vestra's own, Claude Code and Codex at the same time. Each teammate's engine shows on its desk tag and its receipts.

Which engine is best?

It depends on the job. Coding engines like Claude Code and Codex suit building and reviewing software; Vestra's own runs every chief and suits everyday business work. Arena's 2026 study found engines differ more in cost than in success, so try two on your own work and read the receipts.

Will switching engines make my agent forget things?

Not in Vestra. A teammate's job, goals, skills, apps, routines, memory and kit belong to the teammate, not the engine. The next piece of work starts on the new engine, and if it isn't better, you switch back without losing anything.

Do the safety rules depend on the engine?

Not in Vestra. Every engine works under the same office rules: spending over the limit, deleting something and contacting someone new always wait for a person, and the same caps and receipts apply. On their own, each engine has its own permission settings.

Does an engine cost more in Vestra?

No. One credit is one cent, the same on every engine, and every piece of work shows its cost on a receipt. Plans start at $19 a month with 2,000 credits, and every new office gets 1,000 credits free.

Do I need my own Claude or ChatGPT plan to run a teammate on Claude Code or Codex?

Vestra's handbook prices every engine in the same Vestra credits and doesn't mention a separate Claude or ChatGPT plan. If this matters for your setup, ask the Vestra team when you start.

Can I run Gemini, Grok or Muse as an engine in Vestra?

They appear in Vestra's engine picker, but today the live engines are Vestra's own, Claude Code and Codex. Vestra says it keeps its live list current as things ship.

Do I need to be technical to choose an engine?

No. Your chief suggests an engine when it hires a teammate and explains why in plain words. You can accept it, pick another or let your chief choose job by job. If you are technical, you can choose exactly which engine each teammate runs on.

Why not just use Claude Code and Codex on their own?

You can, and for one developer working alone they're excellent. But each works for one person in one session, with its own memory, rules and bill. Use both, and you become the glue between them. Vestra runs them as teammates under one chief, one memory, one set of rules and one receipt.

Can my agents run in my own cloud?

The handbook describes three places agents can run: Vestra's cloud, your own cloud or your own premises, with the same office, rules and receipts in all three. Running in your own cloud or on your premises is part of Vestra's Enterprise plan.

What does "model lock-in" mean, and does an engine cause it?

Lock-in means it's hard to move away from one maker. Engines tend to cause it, because each one is tuned for its maker's models and holds your instructions and history. Keeping the job above the engine, as Vestra does, means a new engine is an upgrade, not a migration.

Glossary

  • Agent: an AI that can take actions to finish a task, not just answer. It includes an engine, a model, tools, instructions and rules.
  • AI agent engine: the working layer of an agent; it runs the model in a loop with tools until the task is done. Also called a harness or runtime.
  • AGENTS.md: a plain text file of instructions that several coding agents, including Codex and Claude Code, can read.
  • Agent SDK: Anthropic's library for developers that exposes Claude Code's tools, loop and context management in Python and TypeScript.
  • Chief: in Vestra, the agent that runs your other agents, speaks for you and answers to you. Every chief runs on Vestra's own engine.
  • Context: what the engine shows the model at each step: the task, instructions, files and results so far.
  • Credit: Vestra's unit of cost. One credit is one cent, the same on every engine.
  • Framework: a code kit developers use to build their own agents or engines, such as LangChain or Google's ADK.
  • Harness: the engineers' word for an engine.
  • Kit: in Vestra, what every agent works with: a computer, and over time a phone, an inbox, a vault and your business tools.
  • MCP (Model Context Protocol): an open standard for connecting AI agents to outside tools and data.
  • Model: the AI brain that reads and writes text, trained by a lab. Claude Opus and GPT-6 are models.
  • Permission mode: an engine's setting for what it does alone and what needs your yes.
  • Platform: a hosted service where agents are deployed and run, with extras like memory and logs.
  • Reasoning effort: a setting in some engines, such as Codex, for how much the model thinks before acting.
  • Receipt: in Vestra, the record of what a piece of work cost, who did it and who said yes.
  • Runtime: another word for an engine, leaning toward where and how the loop runs.
  • Subagent: a helper an engine starts for part of a task, which reports back to the main thread.
  • Teammate: in Vestra, an agent hired for a whole job with goals, shaped by you, on the engine you pick.

Sources