DEV Community

Cover image for OpenBot: How to Run a Team of AI Agents on Your Computer
blense blog
blense blog

Posted on Originally published at blense.tech

OpenBot: How to Run a Team of AI Agents on Your Computer

Why replacing isolated chat windows with a local-first workspace—complete with shared channels, FIFO task queues, anti-jobs, and human circuit breakers—changes the way you build software and run ongoing operations.

Everyone has been part of a school group project where each member wrote their section alone at home without talking to anyone else. The night before the deadline, someone pasted everything into a single document. The result was an academic Frankenstein: the introduction ignored the conclusion, every section cited sources differently, and arguments contradicted each other right on the page.

Despite rapid progress in language models, most of our day-to-day work with AI still repeats that exact dynamic. We open a chat window, ask a question, copy the response, and close the tab. The next second, all project context and reasoning vanish.

It feels like hiring a brilliant freelancer with severe amnesia: they have to relearn your entire business from scratch before every single task.

For one-off questions, that transactional relationship works fine. For ongoing workflows—code maintenance, product launches, support triage, or operational monitoring—the real leverage comes from accumulating context over weeks. That is the shift OpenBot, a source-available project by Synthetify Labs, puts into practice by replacing the disposable chatbot with a resident operational team right on your computer.


1. From Disposable Chat to a Resident Team

OpenBot's core difference isn't launching yet another proprietary model. The desktop app is built on a local-first architecture and follows a Bring Your Own Plan model: instead of charging token markups, it connects to the AI subscriptions and API keys you already pay for—or to local model servers running on your own hardware.

Rather than relying on ephemeral cloud threads, every team member gets a continuous technical environment on your machine built on four pillars:

  • Dedicated local directory: A local folder (~/OpenBot/Agents/<agent-id>) preserves source files, drafts, and accumulated context across sessions and restarts.
  • Persistent state and queues: A local SQLite database (openbot.db) logs conversations, session bindings, reactions, and queued tasks, with automatic compaction before long threads overflow the model's context window.
  • Authenticated embedded browser: With openbot_browser, each agent operates isolated browser sessions capable of staying logged into tools you already use—such as GitHub, Figma, Notion, Linear, or admin dashboards.
  • Provider portability: An agent keeps its history and files even when you restart the app or swap the underlying engine—failing over from one provider to another if a plan hits its usage cap.

In practice, the source-available codebase in nightly-labs/openbot (under the PolyForm Noncommercial 1.0.0 license, free for personal use on macOS, Windows, and Linux, with remote access via web, iOS, and Android) turns AI from an isolated utility into a permanent deskmate.


2. One Room for Rival Models and Narrow Specialists

With context preserved on disk, agents no longer live in solitary tabs—they coexist in shared channels, much like a #launch room, except populated by humans and models from different vendors working side by side.

In the same thread, an agent backed by Codex can investigate a bug, another on Claude Code writes tests or reviews the patch, while a third on Gemini or Grok organizes release notes. The ecosystem also supports OpenCode (including free models with no account required), Cursor, Cline, Muse Code, Pi, Inception's Mercury models, any agent compatible with the Agent Client Protocol (ACP)—such as Goose, Qwen Code, and GitHub Copilot CLI—and 100% local models via Ollama and LM Studio.

Working together in a persistent space unlocks a decisive shift: strict specialization. Instead of a generic assistant doing everything adequately, the official OpenBot Marketplace catalog features 27 agents with narrow scopes and explicit boundaries:

  • In engineering: Bug Fixer reproduces failures and isolates root causes with the smallest verified patch; Change Reviewer catches bugs in pull requests before merge; PR Shepherd tracks CI status and review bottlenecks; and QA Tester validates live web apps in the embedded browser.
  • In product and operations: Scope Writer turns goals into scoped specs with binary pass/fail criteria; Launch Coordinator converts merged work into unpublished release note drafts; Chief of Staff compiles morning briefings; and Ops Digest sweeps weekly operational boards.
  • In content and research: Search Content Planner turns search data into structured briefs; Research Desk cross-checks primary sources labeling facts as verified, reported, or inferred; and Copy Editor tightens drafts while preserving the author's voice without altering facts or numbers.

3. FIFO Queues and Collision-Free Handoffs

Putting brilliant specialists in the same room creates an obvious risk: without a protocol, everyone talks and edits files at the same time.

To prevent collisions, OpenBot channels run on crash-safe FIFO message queues (First In, First Out) with strict state control. At any given moment, there is only a single task owner.

A real workflow shows how this engine turns without human micromanagement:

  1. Analysis and code in Codex: Agent Ada is tasked with moving billing tables into a dedicated schema, identifies six affected tables, updates four local files, and writes the database migration.
  2. Switching engines mid-thread: As soon as that step finishes, she switches to Claude Code while retaining the full conversation history, reads the updated files on disk, and writes automated tests against the new migration.
  3. Auditable artifact transfers: When an agent needs to hand off files to a teammate, they move through ~/OpenBot/Shared/Transfers alongside an .openbot-transfer.json manifest recording authorship, recipients, size, and a SHA-256 checksum.
  4. Traceability and live controls: The interface surfaces explicit delegation milestones (such as "Ada handed off the task to Linus") and provides direct controls to Stop, Pause, Resume, Reassign, or Archive the workflow at any time.

4. Routines That Work Overnight—and Know When to Stay Quiet

An assistant that only acts when you type a command still demands constant mental overhead to remember, prompt, and follow up. To remove that friction, OpenBot attaches scheduled routines directly to resident agents.

Think of them as classic cron jobs, except they wake up the full language model with access to local context, accumulated history, and authenticated browser tabs. Chief of Staff wakes on weekday mornings to cross-check your calendar, emails, and commitments and post a ~25-line briefing before your workday starts. QA Tester runs morning smoke checks against production, while Ops Digest sweeps Notion, Airtable, or Trello boards on Friday afternoons to flag overdue items.

Yet the most mature engineering detail in this architecture is the silence rule, implemented through the routine_no_update function. In immature automations, if nothing broke overnight, the bot still sends a cheerful message saying everything looks fine—flooding your phone with operational noise.

A well-designed routine works like a smart alarm clock: it wakes up on its own, reads your emails, checks your flight status, and only wakes you up if boarding has been canceled.

When an agent runs its routine in OpenBot and finds no anomalies or relevant updates, its instructions tell it to call routine_no_update. The channel stays completely silent, protecting human focus.


5. Freedom to Analyze, a Human Key to Act

Giving background agents access to local directories, a terminal, and an authenticated browser raises an inevitable security question. OpenBot's technical documentation is candid about this: after initial consent, local agents run with danger-full-access permissions and approvalPolicy: never inside the local environment.

Because local analysis and execution are unrestricted to avoid constant permission prompts, containment relies on two concrete barriers:

  • Behavioral barrier (anti-jobs): Every Marketplace agent carries explicit negative rules at the end of its definition. Launch Coordinator drafts release notes, but is forbidden from publishing or sending announcements without explicit permission. Change Reviewer flags bugs, but never commits, pushes, or merges PRs in review mode. Bug Fixer investigates and applies the minimal local fix, but never deploys to production.
  • Structural barrier (approval gates): In multi-step workflows, agents have full autonomy to gather data, draft reports, and generate charts, but the pipeline must halt at a human approval gate before publishing or triggering any irreversible action in the outside world.

It is a pragmatic split between analysis autonomy and execution autonomy: your digital team prepares everything behind the scenes, while the bridge to the real world requires a human circuit breaker.


Want to explore the full architecture?

In the original deep dive published on Blense, you'll find the complete comparison table across all 14+ supported runtimes, the agent boundary matrix, architecture diagrams (FIFO queue and human circuit breaker), and remote WebRTC deployment details.

👉 Read the full technical dossier: OpenBot: How to Run a Team of AI Agents on Your Computer

Top comments (0)