Technical Dossier · OpenBot (v0.71.0 · Local-First)
- Persistent workspaces in ~/OpenBot/Agents/, SQLite event logs (openbot.db), and an embedded browser remain on the user's machine.
- Supports 14+ runtimes (Codex, Claude Code, Gemini, Grok, OpenCode, Cursor, Cline, ACP, Ollama, and LM Studio) while preserving conversation history across model switches.
- Shared channels enforce single task ownership and crash-safe FIFO queues to prevent collisions between agents.
- Two-layer safety model: explicit negative constraints (anti-jobs) and mandatory human approval gates before irreversible external actions.
Structural Platform Indicators
Architecture
Local-First
Workspaces in ~/OpenBot/Agents/, SQLite event logs, and the embedded browser live on your machine.
Providers
14+ Runtimes
Codex, Claude Code, Gemini, Grok, OpenCode, Cursor, Cline, ACP, Ollama, and LM Studio.
Specialization
27 Agents
Official catalog with narrow roles, reusable local skills, and negative constraints (anti-jobs).
Economic Model
$0 Personal
Free for personal use with no gated features, connected to the AI plans you already pay for (BYO Plan).
Project analyzed: OpenBot (Synthetify Labs) · PolyForm Noncommercial 1.0.0 License
The end of transactional amnesia and fragmented group work#
Anyone who has ever been part of a rushed group project knows the script: each member works in isolation without seeing what their teammates decided, and the night before the deadline someone tries to stitch everything into a single document. The result is usually a disjointed patchwork where the introduction ignores the conclusion and assumptions contradict one another.
Curiously, most contemporary interaction with artificial intelligence repeats that exact dynamic. You open a chat window, ask a question, get an answer, close the tab, and end the cycle. Every line of reasoning, project convention, and decision made there evaporates. On the next task, it feels like hiring a brilliant specialist suffering from severe amnesia who has to relearn your business from scratch every morning.
For one-off questions, that purely transactional relationship is enough. For ongoing operations—software development, support triage, release preparation, or operational monitoring—the real value lies in accumulating context over weeks. That is the premise behind OpenBot, built by Synthetify Labs: instead of offering yet another language model, the desktop app creates a persistent operational environment where different models work as a resident team on your computer.
Product Principle: “The structural shift isn't answering an isolated question better—it's giving each agent its own workspace and putting them in the same room.”
Paradigm shift: ephemeral chat window vs. persistent workspace#
| Dimension | Traditional AI Chat | OpenBot (Persistent Workspace) |
|---|---|---|
| Memory & Context | Linear history isolated per conversation; context is lost when opening a new tab. | Each agent keeps a local directory, continuous history in openbot.db, and automatic compaction before exhausting the model's context window. |
| Tool Access | Limited to manual file uploads or temporary cloud sandboxes. | Direct read/write access in ~/OpenBot/Agents/<id>, shell command execution, plugins, and an embedded browser (openbot_browser) with authenticated sessions. |
| Model Portability | Locked into that interface's provider; switching LLMs means starting over. | An agent preserves chat and files when switching across Codex, Claude, Gemini, Grok, or local models, with automatic quota-limit fallback. |
| Collaboration | Single-player mode (one user per thread); manual copy-pasting between tabs. | Multiplayer shared channels: humans and multiple agents exchange messages, hand off tasks, and transfer managed files. |
| Operational Cadence | Purely reactive; nothing happens unless the user types a prompt. | Crash-safe FIFO queues and scheduled routines, with silent suppression via routine_no_update when nothing has changed. |
| Data Custody | Conversations and files reside on the chat vendor's servers. | Files, threads, attachments, and browser cookies stay on the host machine; only outgoing prompts are sent to the chosen provider. |
What it means to be resident on your computer#
In OpenBot's technical specifications, calling an agent “resident” is not marketing shorthand for saving chats in the cloud. Persistence is rooted in the local filesystem and database of the Electron desktop application (built with TypeScript, SolidJS, and Bun).
When created—from a single descriptive prompt you can review before saving—each agent receives a dedicated directory at ~/OpenBot/Agents/<agent-id>, alongside access to a shared area at ~/OpenBot/Shared. When an agent needs to hand off artifacts or screenshots to a teammate, the system routes them through ~/OpenBot/Shared/Transfers, generating an .openbot-transfer.json manifest that records ownership, recipients, file size, and a SHA-256 checksum for full traceability.
The entire timeline—messages, provider session bindings, queues, reactions, and attachment indexes—is written locally to the canonical openbot.db SQLite log. Additionally, each agent gets isolated sessions in the embedded openbot_browser, allowing it to stay logged into tools like GitHub, Linear, Notion, Figma, or admin dashboards without exposing internal app APIs (window.openbot) to visited web pages.
~/OpenBot/Agents/<id>(Private per Agent): Dedicated working directory. Source code, drafts, reports, and project files persist across sessions and app restarts.~/OpenBot/Shared/Transfers(Auditable Handoffs): Files shared between agents are accompanied by an.openbot-transfer.jsonmanifest with authorship, recipients, and SHA-256 integrity.userData/openbot.db(Canonical Log): Local SQLite database storing conversation events, FIFO queue state, provider session references, and context-window tracking.provider-runtimes(Pinned Binaries): Single local store for CLIs downloaded and managed by OpenBot, without copying credentials and respecting environment variable overrides.
Local-first does not mean offline-only: Workspaces, history, attachments, and browser sessions remain on your machine—never on Synthetify Labs' servers. However, prompts sent to agents still travel to the selected provider (OpenAI, Anthropic, Google, xAI, etc.). For 100% air-gapped local execution, OpenBot natively integrates Ollama and LM Studio.
Provider portability without losing team memory#
One of OpenBot's most practical architectural choices is decoupling an agent's identity from the inference engine powering it at any given moment. Rather than locking a role to a single vendor, you connect the accounts or local CLIs you already use—such as Codex (via a ChatGPT plan), Claude Code (via a Claude plan), Gemini (Google AI Pro/Ultra via Antigravity CLI), Grok (xAI), Cursor CLI, Cline, OpenCode, Muse Code, Pi, Mercury (Inception), Kimi, Devin, GitHub Copilot, Mistral Vibe, or Hermes Agent—along with any runtime compatible with the Agent Client Protocol (ACP) and OpenAI-compatible endpoints.
In practice, the unified conversation history belongs to the agent inside openbot.db, while native CLI session IDs are stored solely to resume each runtime's internal state. This yields two immediate advantages: first, if one plan hits its usage cap or experiences downtime, the agent can automatically fail over to a backup model on another provider—posting a discreet note in the chat—and pick up right where it left off.
Second, a single agent can combine the strengths of different models within the same task. In the platform's official examples, the agent Ada uses Codex to read billing code, move tables into a dedicated schema across four files, and write the database migration. Immediately afterward, she switches to Claude Code and continues in the same thread, writing automated tests directly against the newly created migration with zero manual recapping. (Note: agents backed by Cursor CLI and Cline CLI remain strictly confined to the local machine and are not exposed to remote teammates via the Team API.)
| Provider / Runtime | Auth / Plan | Execution Mechanism | Native CLI Storage |
|---|---|---|---|
| Codex | ChatGPT subscription | Local Codex App Server (stdio) | ~/.codex (login and thread history) |
| Claude Code | Claude subscription | Native Claude Code CLI | ~/.claude (login and sessions) |
| Gemini | Google AI Pro / Ultra | Antigravity CLI (1.5.3+) via local OAuth | ~/.gemini or $GEMINI_HOME |
| Grok | xAI account or XAI_API_KEY | Grok CLI (key never persisted to disk) | ~/.grok |
| OpenCode | Free without account or OpenCode Go key | OpenCode CLI pinned by OpenBot | Go key encrypted locally |
| Cursor / Cline | Own plan or API key | cursor-agent acp / cline --acp | ~/.cursor/openbot-confined / ~/.cline |
| Copilot / Mistral / Kimi / Devin | Own accounts or tokens | Integration via ACP protocol | OS Keychain or dedicated XDG folders |
| Hermes / Custom ACP | Nous Portal or local providers | hermes acp or ACP binary (Goose, Qwen Code) | ~/.hermes (memories, skills, and SOUL.md) |
| Ollama / LM Studio | None (100% local) | Auto-detection of OpenAI-compatible server | Models and files never leave your computer |
How agents pass the baton without stepping on each other#
Putting several intelligent agents in the same room solves isolation, but introduces a classic distributed-systems problem: if everyone talks and edits files at once, the workspace devolves into conflicts and overwrites. OpenBot's answer pairs conversational organization—shared channels like #launch—with strict queue and ownership discipline.
Inside a channel, humans (including invited teammates in multiplayer mode or users connected via iOS and Android mobile apps) and agents follow the same stream of messages and deliverables. Yet the UI state machine guarantees that at any given moment, there is only a single task owner holding explicit active delegation. Messages sent while an agent is busy wait in a crash-safe FIFO queue (first-in, first-out).
For anyone supervising the channel, control is granular and immediate: every thread offers native actions to Stop, Pause, Resume, Reassign, Archive, and Restore the task, displaying clear handoff milestones. In a real bug-fix workflow inside #launch, Ada spots a failing Safari login test and hands it off to Linus, who patches session.ts and passes it to Grace to review and merge before Ada closes the issue.
Bounded specialists instead of a generic do-everything bot#
Because context survives across runs, building a single “bot that does everything” stops making sense. The official OpenBot Marketplace catalog lists 27 curated agents across Productivity, Docs, Design, Research, Data, Automation, and Coding—supplemented by plugins (Linear, Notion, Figma, Canva, Obsidian, Aave, GitHub gh, Todoist, Trello, Airtable) and reusable local skills authored by the agents themselves via create_skill.
What stands out most in these profiles is the strictness of their boundaries: each agent knows its single job, which sources it must inspect before answering, and—above all—what belongs to the colleague next door. When a request falls outside its remit, its instructions tell it to name the right specialist and stop.
- Launch Coordinator (Releases): Turns merged PRs (
gh) and issues (Linear, Notion) into “Draft, unpublished” release notes and a checklist with owner, date, and pass/fail criteria. Anti-job: never publishes, sends announcements, or closes issues without permission (testing belongs to QA Tester; copyediting to Copy Editor). - QA Tester (Quality): Validates live web apps in
openbot_browserin a clean tab against an acceptance checklist, issuing a PASS, FAIL, or BLOCKED verdict with step-by-step screenshots. Anti-job: never uses real customer data, makes purchases, alters production, or patches code (that belongs to Bug Fixer). - Bug Fixer (Engineering): Reproduces a reported failure, isolates the first state divergence, tests up to 3 hypotheses, and applies the smallest verified fix. Anti-job: never commits, pushes, merges, deploys, or touches out-of-scope code without explicit authorization.
- Change Reviewer (Code Review): Catches bugs before merge in PRs or local diffs by inspecting callers of every changed function and concluding with DO NOT MERGE, FIX FIRST, or OK TO MERGE. Anti-job: never edits, commits, or approves PRs while in review mode.
- Chief of Staff (Operations): Delivers a single-screen (~25-line) morning briefing covering the day's meetings, due commitments, and pending replies, extracting decisions with verbatim quotes. Anti-job: never sends emails, moves meetings, or marks tasks complete on its own.
- Dr. Eggbot (Meta-Agent): Designs high-craft agents around a single-focus rule (one job, one voice, zero spare tools) and audits wasted routines. Anti-job: never creates skills, agents, or routines from an audit report until the user chooses first.
Boundary matrix: who does what across the operational cycle#
| Agent | Trigger / Routine | Primary Sources | Explicit Boundary (Hands off to) |
|---|---|---|---|
| PR Shepherd | Weekdays at 10:00 and 15:00 | Repository + gh CLI + watched_repos table | First-pass review goes to Change Reviewer; new bugs go to Bug Fixer. |
| Ops Digest | Friday afternoons | Spreadsheets, Airtable, Notion, Trello, and open trackers | One-off project plans belong to Scope Writer. |
| Request Triage Desk | On demand (inbox + calendar) | Inbox + calendar to check scheduling conflicts | Sales leads go to Prospect Researcher; support tickets to Support Reply Desk. |
| Prototype Builder | On demand (idea / Figma) | Scope doc, screenshot, or Figma plugin | Production code goes to a coding agent; visual critique to Design Critic. |
| Skill Smith | On demand (repetitive API) | API documentation + one live read request | Creating new agents belongs to Dr. Eggbot; never writes API keys into files. |
| Research Desk | On demand (open question) | Primary sources opened in browser + Notion | Campaign metrics go to Campaign Analyst; prospecting to Prospect Researcher. |
Background work and the elegance of the silence rule#
An assistant that requires someone to type a prompt every morning still consumes management overhead. To eliminate that bottleneck, OpenBot attaches scheduled triggers to agents. Unlike a traditional cron job—which runs a rigid, blind script—a scheduled routine wakes the full agent with all of its local context, accumulated history, and authenticated sessions intact.
Accordingly, Chief of Staff wakes up on weekday mornings to cross-check emails and calendars before the workday starts; QA Tester runs a quick smoke check against your saved production URL; PR Shepherd checks at 10:00 and 15:00 whether watched pull requests have picked up merge conflicts, CI failures, or review requests; and Ops Digest sweeps spreadsheets and boards every Friday afternoon.
Yet the most mature engineering detail in this architecture is not what the agent posts, but what it chooses not to say. In immature automation setups, every passing check produces a zero-value message—“All checked, no issues found”—flooding the team's phones with operational noise. In OpenBot, scheduled agents obey an explicit silence rule: if nothing changed, nothing broke, and no item went overdue since the last run, the agent calls routine_no_update and posts nothing to the channel. Humans are interrupted only when there is a real anomaly or strategic decision to make.
Full access for analysis, human key for execution#
Giving autonomous agents continuous access to the filesystem, terminal, and a browser already logged into company services raises an unavoidable security question: what stops a model hallucination from deleting a critical directory or publishing an inaccurate announcement?
The repository's official documentation addresses this head-on. After explicit consent on first launch, local agents run unrestricted (danger-full-access with approvalPolicy: never) within their directories and host system without prompting for confirmation on every intermediate command. To keep that power safe, the architecture relies on two complementary containment layers.
The first is behavioral, encoded into each agent's anti-jobs: a writer never sends emails, a reviewer never approves or merges a PR, a tester never touches production settings, and a launch coordinator outputs only drafts labeled unpublished. The second barrier is structural, built directly into multi-step workflows: agents have wide latitude to read data, write code, generate charts, and stage deliverables, but the pipeline must pause at a human approval gate before executing any irreversible action in the outside world.
Anatomy of a chained weekly workflow with a human circuit breaker#
- Scheduled Trigger: Every Monday at 09:00, the workflow starts automatically without manual intervention.
- Ada · Synthesis: Summarizes issues closed and opened over the past week in the repository.
- Grace · Data: Collects and consolidates operational usage metrics for the period.
- Linus · Writing: Drafts the weekly report combining Ada's summary and Grace's metrics.
- Alan · Charts: Generates numerical visualizations and attaches the files to the final package.
- Human Approval: The workflow halts at “Publish the report? Approve” until the human operator clicks confirm.
From your desktop workstation to distributed teams#
Although built around a local-first desktop experience—with native binaries for macOS 13+ (Apple Silicon and Intel), Windows 10+ (x64), and Linux (x64 and arm64 via AppImage, plus a Nix package)—OpenBot is designed to scale beyond a single laptop. Users can keep an always-on Mac mini or Linux server (Ubuntu 24.04/26.04 via systemd or a Docker container using a seccomp.json profile) running continuously and access the exact same team from a web browser or native iOS and Android apps.
In that remote setup, the host's Team API stays bound strictly to loopback. The signaling service brokers only the initial connection handshake, while messages, RPC events, and binary file transfers travel end-to-end encrypted over WebRTC v3 (falling back to a coturn relay when required), keeping accounts and invites on Cloudflare Workers/D1 without ever routing chats or source code through third-party servers. For organizations that prefer not to manage infrastructure or need a commercial license, OpenBot for Teams provides managed servers with custom integrations.
The conceptual leap OpenBot delivers is turning AI from a one-off advisor into auditable organizational infrastructure. By combining persistent local directories, provider portability, ordered channel delegation, and the quiet discipline of interrupting humans only for real exceptions or critical approvals, AI-assisted work stops being a trail of forgotten browser tabs and starts operating like a continuous team.
Sources & Reference Documentation#
- Synthetify Labs — OpenBot Repository: architecture documentation, network boundaries, local storage, security (
danger-full-access), and installation guides (github.com/nightly-labs/openbot). - Official OpenBot Portal & Guides: product overview, multiplayer mode, approval-gated workflows, and provider matrix (openbot.run).
- OpenBot Marketplace: operational specs and constraints (anti-jobs) for Launch Coordinator, QA Tester, Bug Fixer, Change Reviewer, PR Shepherd, Chief of Staff, Ops Digest, and Dr. Eggbot.
