---
title: "Cerevisor: A Local-First AI Agent Orchestration Platform for Multi-Agent Workflows"
slug: ai-agent-orchestration-platform
date: 2026-06-27
excerpt: "Cerevisor is a local-first, provider-agnostic AI agent orchestration platform: a desktop app to visually build and natively run multi-agent workflows across major AI agent providers. Here is everything it does today, plus what shipped in the v1.5 and v1.6 releases: lifecycle hooks, unified looping, an Antigravity provider, and more."
featured_image: "https://bbtxujdxvidaghmhxkqs.supabase.co/storage/v1/object/public/generated-images/blog-1782411851638-ai-agent-orchestration-platform.webp"
featured_image_alt: "Abstract blue-gray illustration of hexagonal AI agent nodes connected by edges on a canvas, with small charts and flow icons, representing an AI agent orchestration platform."
canonical_url: https://cerevisor.com/blog/ai-agent-orchestration-platform
updated_at: 2026-06-25T18:24:13.174317+00:00
---

# Cerevisor: A Local-First AI Agent Orchestration Platform for Multi-Agent Workflows

TLDR

For a long time, this was my private workshop. Today it meets the world. Cerevisor is a local-first AI agent orchestration platform where a whole team of AI agents gets designed on a visual canvas and run natively across any model provider, an intelligent system that learns from every run while keeping all of it on the machine it runs on, with no telemetry. The v1.5 and v1.6 releases bring lifecycle hooks, unified non-destructive looping, and a seventh provider, the moment it finally steps into the open.

I built Cerevisor because I kept hitting the same wall. The visual tools could draw a pretty agent graph and then hand me a prompt to run somewhere else. The agentic runtimes I actually liked, Claude Code, Cursor, Codex, ran a single agent beautifully but gave me no canvas to wire up a whole team, and no way to see the workflow as one thing. So I built the tool I wanted: a local-first desktop **AI agent orchestration platform** where I design multi-agent workflows visually and run them natively, on whichever model provider I choose. Cerevisor (formerly Opaal) lives in that gap on purpose.

Three things make it what it is. It is **provider-agnostic**, so inside one workflow a researcher agent can run on Anthropic, a reviewer on Cursor, and a coder on a local Ollama endpoint, each native to its own provider, with no single vendor owning the stack. It is **local-first with no telemetry**: memory, analytics, and learned model routing all run on the machine, and there are zero outbound network paths for the data today. And it keeps orchestration inspectable. Control flow, file handoffs, iteration, lifecycle gates, all of it is visible and editable on the workflow itself instead of buried in prompt text nobody can see or audit.

Here is the tour: what Cerevisor’s AI agent orchestration does today, then what shipped across the v1.5 and v1.6 releases.

Watch Cerevisor run a multi-agent workflow natively, with agents executing wave by wave on the canvas.

## Building AI Agents and Multi-Agent Workflows on a No-Code Canvas

The canvas reads left to right, laid out in phases. Agents inside a phase run together, and phases run in order. That is the whole mental model, and it means parallel and sequential work get composed visually, with no scheduling logic to write. Drag an agent card onto the canvas, a zoom-and-pan surface with a minimap, and configure it in depth without writing code.

Each agent gets a role from a broad library, research, architecture, development, review, testing, documentation, content production, and more, or a custom one. Then it gets instructions, a clear definition of what good output looks like, the skills it needs, and the files it reads and writes. The advanced controls are there when wanted: how the agent reasons, which model it prefers, what it is allowed to touch, and how it recovers when something breaks.

### Control Flow: Conditional, Approval-Gate, and Loop Connections

Connections wire up automatically by column adjacency, and every edge can be overridden by hand. Manual wires always survive a re-layout, and accidental cycles get blocked unless a loop edge is drawn on purpose.

What makes this more than a static diagram is that control flow lives on the edges themselves. Any connection can become:

- **Conditional**: it flows only when a natural-language condition is met, with an else-branch.

- **Approval gate**: it pauses the run for a human yes or no, with a custom prompt.

- **Loop**: it repeats until an exit condition, up to a cap.

Each connection also decides how much an agent passes downstream: a short summary, structured data, a file pointer, or the full output. On big fan-in workflows that matters more than it sounds, because Cerevisor keeps each agent seeing only what it needs, so context and cost stay in check. Most single-agent harnesses have no way to even express that.

### Three Ways to Build an AI Agent Workflow: Canvas, Templates, and No-Code Chat

There are three ways to build a workflow, and they all stay in sync on the same underlying document. Drive the canvas directly. Start from a template for a common job: codebase review, a feature build, a bug fix, content and research production, a compounding weekly second-brain review. Or just describe what is needed in plain language and let Chat-to-build assemble it, which is about as no-code as an AI agent builder gets. The chat builder adds and connects agents, assigns skills and files, sets roles and control flow, and will even inspect, explain, and run what it just built. It asks clarifying questions when the request is fuzzy, and it reads dropped files, images, text, PDFs, so it builds against real material instead of guesses. As of v1.6 it runs on delegated providers too, and it knows the active workflow’s folder and world files when it proposes edits.

Zoom out and workflows live together on a world view: one shared canvas where each workflow is a frame on a rail, with cross-workflow trade-route links so one workflow’s output feeds the next. Old single-workflow files just wrap themselves into a one-workflow workspace when they load. Nothing to migrate.

There is an in-app Skill Workshop for building, validating, and scaffolding SKILL.md skills without leaving Cerevisor, with AI help on the drafting. Skill retrieval understands intent, so describing what an agent should do, say build a dashboard UI with React, surfaces the right skill even with no name match. And any workflow can be exported as a prompt: a project-manager-style brief, execution order, per-agent definitions, data flow, permissions, deliverables, written to a CLAUDE.md or copied to the clipboard, with a live completeness score from 0 to 100 percent. Handy for anyone who would rather drive it through an external harness.

## Running Multi-Agent Workflows: A Harness for Every AI Agent Provider

Hit run and Cerevisor executes the workflow itself: driving each agent to completion, handling phase orchestration, dependencies, and file awareness, and passing results cleanly from one agent to the next, with the whole multi-agent run visible on the canvas. The one question that sorts providers apart is simple. Does Cerevisor run the agent, or hand it off to an external tool?

### A Harness for Harnesses: Seven AI Agent Providers in Two Loop-Ownership Families

Cerevisor works with a broad and growing roster of AI agent providers, sorted by that one question, who actually runs the agent:

- **Cerevisor runs it**: the major cloud APIs (Anthropic, Gemini) plus any OpenAI-compatible or self-hosted endpoint, local models through Ollama, vLLM, and LM Studio, hosted options like Together, Groq, Fireworks, and OpenRouter. This is the fullest-control lane: every tool call passes through the permission system, and file intelligence, output gates, mid-run agent chat, and every iteration mode apply.

- **Delegate to an external harness**: leading agent tools like Codex, Cursor, Claude Code, and Google’s Antigravity. Here the run happens on that tool’s own agent, with its quotas, behavior, and tools; Cerevisor sets the sandbox and approval policy up front and flags the trade-off with a one-time heads-up at setup.

Either way, it is one canvas, one AI agent platform, over all of them. Cerevisor also treats how an agent runs and how it gets billed as separate questions, so cost shows up accurately whether the run is on a subscription, billed per token, or on free local models, all in the same workflow. Codex on a ChatGPT subscription and Antigravity on a Google AI plan both come in at zero against the token budget.

> A harness for harnesses: one canvas over every AI agent provider, local or hosted, with no single vendor owning the stack.

Any agent can run on its own provider, or just inherit a sensible default, so a mixed-provider workflow sends each agent to the runtime it should use, with no per-agent fiddling unless wanted. That is the heart of what makes this an AI agent orchestration framework and not a wrapper around one vendor.

### Dynamic Model Routing Across AI Agent Providers

Cerevisor routes models for me, and it does it model-agnostically. Nothing is pinned to a specific model name. Leave an agent on automatic and it picks a fitting model for the job, leaning toward cost, balance, or quality as set, always inside what the provider actually offers, and falling back safely when it is unsure. Keeping routing dynamic instead of hardwired to a static table is what keeps workflows running as models come and go, renamed, retired, or replaced. Model names are the one thing in this industry I have stopped trusting to stay put.

### Agent Tools, MCP Servers, and a Three-Tier Permission Model

Cerevisor-loop agents come with a deep built-in toolset across files, search, web, and execution, and they extend through any MCP server’s tools, because Cerevisor is a first-class MCP client, not a server. Every tool is risk-graded, so routine actions move fast while the consequential ones ask first, and an attached MCP server’s tools fall under the same controls as everything else. Delegated providers bring their own catalog.

The permission model is built to stay safe and stay out of the way at the same time. Set a firm ceiling on what a workflow is ever allowed to do, then separately decide how often to be asked about actions inside that ceiling. Trust profiles pick a sane starting point, and the riskiest actions always carry extra guardrails. Every permission decision is logged and durable, so an interrupted run never loses its safety record. Scheduled, unattended runs keep the same hard limits and simply decline anything that would otherwise sit waiting for a human.

## Iterating on AI Agent Workflows: Non-Destructive Loops, Versioning, and Powers

Running an agentic AI workflow once is the floor, not the ceiling. Cerevisor has a whole family of iteration modes, and since the v1.6 unified-looping work they all sit on one non-destructive, versioned re-run substrate.

Non-destructive looping in action: Cerevisor re-runs only what failed and keeps the best round, not the last.

- **Pipeline**: chain several saved workflows in sequence, each one’s output feeding the next, with overall budget limits and per-step failure handling. It is how small proven pieces become a larger automation.

- **Loop & Enhance**: it diagnoses what went wrong on its own, refines the workflow, and re-runs until it converges, with budget and round limits and safeguards so it never spins in circles.

- **Endless mode**: the grow-as-you-go sibling. It keeps extending the workflow toward the goal, building on what is already done without disturbing it, until the intent is met. Growth without rework.

- **Advanced Loop**: a Pro feature that folds fix-and-rerun and grow-as-you-go into one, including automatic fix-then-grow. Clean up first, then build from the improved workflow, with a single cap over the whole run.

- **Resume-from-agent**: re-run one chosen agent and everything downstream from a finished session while leaving the rest untouched, so a single step gets fixed without re-running the graph. An upfront preview shows exactly which agents will re-run, so it never lies.

The substrate underneath is the part I am quietly proud of. Iteration is non-destructive: only what needs another pass gets redone, and work that already succeeded is preserved, so no time or budget gets burned redoing good output. And the best round wins, not the last. Cerevisor keeps the strongest result rather than whatever came out most recently. Every attempt is recorded for browsing, diffing, and rolling back from the new Loop Version History, and none of it ever clutters the real project folder. The working directory is treated as something to protect across dozens of iterations, kept clean, with reversible control over anything a run produces. I have lost enough good work to a careless re-run to care about this one a lot.

Powers round it out: a saved workflow becomes a draggable ability that drops onto an agent. At run time that agent can call the whole sub-workflow as a single step and get back a bounded result, never a context-flooding data dump, while live progress shows separately so a big sub-workflow cannot quietly inflate the calling agent’s context. Powers run inside sensible limits and route each of their own agents to the right provider. Composing entire multi-agent workflows into reusable abilities is something a one-shot harness has no concept of.

The pre-run Workflow Launcher is where all of this gets staged: a non-blocking panel for adding files, typing an instruction, and picking a Smart Mode before dispatch.

## Memory, Learned Model Routing, and Local-First Trust

Cerevisor keeps a persistent, local memory that learns about both the operator and its own behavior across runs: preferences, current focus, and how well it is actually doing. The trust posture around that data is built into the architecture, not just promised in a README. Over time it reflects on that history and surfaces where it is improving or slipping, and what it has learned about the working relationship, all in a Reflection tab. Because the reflection is deterministic, it works on every provider.

Learned model routing turns that history into money saved. As the run history builds up locally, Cerevisor starts pointing out where a cheaper model has been doing just as well for a given kind of work, right there on the agent card, something like “across recent runs this role got aligned output at a fraction of the cost, want to switch?” The advice is grounded entirely in real results, and it computes on-device.

The silent background helpers, run and chat retrospectives, memory and skill crystallization, meta-cognition enrichment, run on whatever provider is set as default, including a subscription provider as of v1.6. If the default ever fails, another key can quietly cover, and any spend that creates is recorded and shown in Analytics, so nothing about cost is a surprise.

Two always-on directives hold every agent to a higher bar. The Wow Directive is a quality bar. The Situational Awareness Directive is an honesty bar: name what is uncertain, back up the load-bearing claims, surface the gaps before declaring success. Both apply automatically to every run and every exported prompt, on every provider, with one toggle to turn them off.

Run-context capture makes a run reconstructable. Every run records the full workflow definition, as structured data and a readable brief, with the initial input and the active directives, plus each agent’s fully-resolved system prompt, all rendered in the System Log as a timeline. A pasted transcript then explains what was asked and wired, not just what came out.

The trust posture is enforced in the architecture, not just promised. Cerevisor classifies what it stores and locks every possible data egress behind an explicit, per-purpose choice that defaults to off. Nothing leaves the machine unless it is deliberately turned on, and there are zero outbound network paths today. A “what does Cerevisor know about me” inventory, plus a full local JSON export, covers data-portability entirely on-device. And what it keeps is patterns and structure about how workflows perform, never prompt content, message bodies, file contents, or anyone else’s identifiers. Even a mishandled future export could not leak surveillance-grade data, because that data is never collected in the first place.

> A firm ceiling on every run, a gate on the risky steps, a durable log of every decision, and analytics on what each model truly costs. That is real governance, not a promise to take on faith.

## Scheduling and AI Workflow Automation: Running Agents on Autopilot

A few surfaces turn Cerevisor from an editor into an always-on AI workflow automation platform. Workflows run on cron or one-time schedules, through the exact same path as a manual run. Flip a schedule to run when closed and Cerevisor fires it even with the app shut, no admin rights needed, so automations land on time whether or not anyone is at the machine. A file-watch trigger, new in v1.6, kicks off a workflow the moment a matching file lands or changes in a folder, handing the run the new file to act on, with safeguards against runaway loops.

Hands-off automation: a Cerevisor workflow running on autopilot.

On Windows, native desktop apps dock into the canvas as nodes that feed agents: Outlook as a full mail and calendar source, plus Explorer, Word, Excel, Edge, and Notepad as window embeds. They are invisibly absent on macOS and Linux rather than half-broken. Agents get live web search through Tavily, Perplexity, or Linkup, with keys tested before they are saved. Auto-update is self-hosted and deliberately license-independent, so a license-server outage can never strand a paying customer on a broken build. And a guarded factory reset, new in v1.6, wipes Cerevisor back to a clean slate, providers, workflows, memory, vault metadata, audit logs, for a fresh start or before handing off a machine.

### A Free AI Agent Builder, Built by Its Maker for His Own Work

Here is the honest version. Cerevisor was not built to be sold first. It was built to be used. I built it as the tool I wanted to depend on every day, the one I reach for to get real multi-agent work done, and I hardened it on my own workflows long before anyone else laid eyes on it. That is the whole design philosophy in one line: it has to be good enough that I trust it myself.

The free version is open to everyone, and it ships with a seven-day trial of Pro, so the full platform is there to feel before any decision. No price list to wade through, nothing to buy to get going. When the trial ends and Pro is the version that fits, the next step is the Pro waitlist, and we bring people on as seats open. Build for free, live in Pro for a week, and tell us whether it earned a place in the daily kit.

## What’s New in Cerevisor: the v1.6 and v1.5 Releases

The last two releases moved Cerevisor from a capable multi-agent builder to something I can run real, repeatable work on, safely, and with a memory of what worked.

### Cerevisor v1.6: Lifecycle Hooks, Unified Looping, and a Seventh AI Agent Provider

**Lifecycle Hooks.** The headline, and the cleanest expression of the harness-for-harnesses idea. A hook runs custom logic, a no-code action, a script, or a webhook, at key moments in a run, and at the blocking moments it can allow, block, or steer. The genuinely new part is gating at the team level: control points across a multi-agent run that a single-agent tool has no graph to even express. Both no-code and power-user paths are covered, point-and-click actions for non-developers, plus a script or HTTP escape hatch that speaks the same protocol common hook tooling already uses, so existing hook scripts run unmodified. Hooks are default-off, Pro-gated, and every fire is recorded in the System Log. No hidden behavior, ever.

**Unified looping across all five loop mechanisms.** Every way Cerevisor iterates, from the simple loop button to fix-and-rerun and grow-as-you-go, now shares the one non-destructive, versioned substrate from the iterating section above. Safe versioned re-running, best-round-wins selection, and the new Loop Version History are free. The most advanced automatic-iteration modes and smarter stopping, ending on a natural-language goal or a verifier on top of the free structural and cost-cap stops, are part of Pro. Either way the project folder stays protected across every iteration, and folder cleanliness runs on every loop for free.

**Antigravity CLI provider.** A new subscription-backed provider that runs agents against a Google AI subscription quota through Google’s agent CLI, widening the lineup. Cerevisor drives it headlessly, with a one-time sign-in tucked safely into the OS keyring.

**Background features now follow the default provider, with automatic failover.** Retrospectives, crystallization, meta-cognition, and the other quiet helpers run on the default provider, including a subscription provider, with any other chat-capable key standing by as a safety net only if the default fails. Any failover spend, one key covering for an exhausted subscription, is recorded and shows up in Analytics, so there are no surprises.

**File-watch triggers and factory reset.** A schedule can now fire a workflow whenever a matching file is created or changed in a watched folder, alongside the existing one-shot and cron triggers. And a guarded Settings action returns Cerevisor to a clean state for a fresh start or a machine handoff.

**Leaner Powers and project-aware chat-to-build.** When an agent invokes a Power now, live progress shows in the agent’s log while the agent itself gets back only a bounded summary, so a big sub-workflow cannot silently inflate its context. The chat builder picked up delegated-provider support and awareness of the active workflow’s folder and world files.

### Cerevisor v1.5: Secrets Vault, Headless Browser, and Model-Comparison Analytics

**Secrets Vault.** A scoped credential store where secrets sit securely in the OS and never get written into workflow files, so sharing or exporting a workspace cannot leak a credential. An agent references a secret by name and the platform supplies it safely at run time, so the value never reaches the model. Secrets can also drop straight into an agent’s environment, and a one-shot migration pulls existing MCP credentials into the vault so they live in one place.

**Headless browser tool.** A browser tool that opens a page, runs JS, reads the DOM, captures console output, and takes screenshots, with nothing extra to install and identical behavior across platforms. Scoped to local content for now.

**Workflow Launcher, run-context suggestions, and resume-from-agent.** Clicking run opens a non-blocking launcher for adding files, typing an instruction, and choosing how much effort the run should spend. Before it starts, Cerevisor suggests relevant context worth including, drawn from prior runs and local files, as suggest-to-confirm chips that need approval, with no hidden model call deciding in the background. Resume-from-agent re-runs one agent and its downstream while preserving everything else from a finished session.

**Analytics overhaul with Model Comparison.** Real charts replaced flat tables, with a shared date-range picker. The new Model Comparison tab shows which models are actually worth it, capability against price, measured on real runs with a transparent, deterministic worked-or-not signal instead of a subjective AI judge. Cheaper models that hold up are easy to spot, and the overpriced ones get obvious fast.

**Plus:** agents can take image input now, with a safeguard when a model cannot process images, a Situational Awareness honesty directive, the foundation for per-user learned model routing, and first-class support for two more major providers, Gemini and Claude Code.

## Who Cerevisor’s AI Agent Orchestration Platform Is For

Cerevisor is for technically literate people who have outgrown single-agent prompting: engineers wiring real multi-step pipelines, technical founders who want AI workflow automation running while they sleep, and careful buyers who care that their data never leaves the machine. The design choices reinforce each other rather than sitting side by side. Provider-agnosticism keeps anyone off a single vendor’s roadmap. The visual graph makes control flow, handoffs, and iteration something to look at instead of something implied. The non-destructive versioned substrate means iteration never destroys work and the best round always wins. And the local-first, default-decline-egress posture is enforced in code, not asserted in a marketing line.

The thread through all of it is that Cerevisor refuses the usual either/or. No choosing between a no-code builder and a real runtime, between Claude and Ollama, between owning the loop and delegating it, or between real memory and real privacy. It is, quite literally, a harness for harnesses, and with lifecycle hooks, unified looping, and a seventh provider now shipped in v1.6, it is the clearest version of that bet so far. It is also still the tool I reach for first, which remains the only product review I fully trust.