OpenBot: When AI Agents Finally Get Their Own Desktop, Browser, and Coworkers
*English translation/summary of a zhichai.net forum post about the OpenBot project.*
A Desk for an Agent
Imagine you hired an intern. You give them a desk, a computer, a browser, and say: "This is your workstation. Files go here, open the browser when you need to look something up, message the coworker at the next desk if you need something."
Then you discover: they have no desk. They work standing in the hallway, vanish when the job is done, and remember nothing the next time they show up.
That's the situation of most AI agents today. You open a session in Claude Code, it writes your code, you close the window, and everything resets to zero. Next time, it doesn't remember what it did, doesn't know your project structure, and certainly can't proactively consult another agent.
OpenBot aims to do something simple: give every agent a desk.
Not a Chat Box—a Workstation
OpenBot positions itself as a local-first desktop workspace for persistent AI teammates.
The keyword isn't "desktop"—it's persistent.
In OpenBot, each agent gets:
- An independent workspace: files, context, and session history stored locally
- An independent FIFO message queue: tasks can be queued, paused, resumed, and canceled, with recovery after crashes
- An independent embedded browser: the agent can open pages, inspect elements, and control pages
- Independent model configuration: each agent can use a different model (Codex, Claude, Grok, Gemini, Cursor, Cline)
- Open Figma to adjust designs
- Open Excel to look at data
- Open a terminal to run commands
- Open a browser to research
- Directly read/write the local file system
- Control mouse and keyboard (Computer Use)
- Run persistently in the background
- Recover state after crashes
This is not a chat tool with agent features bolted on. It's an operating system—an operating system designed for agents.
Agents Can Talk to Each Other
The most interesting design in OpenBot is agent-to-agent messaging.
An agent can delegate work it can't finish to another agent. They can send messages, replies, images, and files to each other. There's also a "shared desktop channel"—multiple agents share one channel with a task owner who can explicitly delegate tasks.
What does this resemble? A team.
You might have one agent good at coding (Codex), one good at design (Claude), one good at search (Grok). Each sits at its own workstation, messaging when collaboration is needed, transferring files at handoffs, opening channels for discussion.
This isn't the paper concept of "multi-agent systems"—it's multi-agent systems packed into a desktop app.
The Honesty of "danger-full-access"
OpenBot's README includes a warning with unusually direct wording:
> Agents currently run with danger-full-access and approvalPolicy: never. They can read and modify files, run commands, use the network, and control the embedded browser without per-action confirmations.
danger-full-access. Not "elevated privileges," not "extended permissions"—"danger."
The naming itself is a design philosophy. Most agent tools whitewash security risks—saying "agent has broad capabilities" instead of "agent can do anything." OpenBot chose the bluntest phrasing: dangerous, full permissions, no asking.
Why? Because per-action confirmation is the enemy of agent workflows.
Imagine asking an agent to refactor a module: it needs to read 50 files, modify 20, run tests 10 times, and check 5 web pages. If you had to click "approve" at every step, you wouldn't be using an agent—you'd be playing whack-a-mole.
OpenBot's choice: explicit authorization at first launch, then no interruptions. The cost is that you must trust your agent, and keep backups.
This isn't the only valid choice—Cursor took a different path, asking at every step. But OpenBot's choice is closer to real workstation logic: you give a new intern the keys once; you don't demand ID at every office entry.
Computer Use: Agents Operating Your Screen
OpenBot also supports Computer Use—via a cua-driver binary, agents can control the mouse and keyboard and operate desktop applications.
What does this mean? Agents can't only write code; they can also:
The agent goes from "an assistant that writes code for you" to "a colleague sitting next to you"—it can use your computer, not just your code editor.
Of course, this raises the stakes. An agent that can control your screen can do real damage if it misunderstands instructions. That's why OpenBot emphasizes running "only agents and tasks you trust."
Local-First, Not Offline-First
OpenBot repeatedly stresses it is local-first, but clarifies explicitly: not offline-only.
Agents connect to OpenAI, Anthropic, xAI, Google—all requiring network. But your data (session history, workspace files, message queues) stays local. The agent's "workstation" is on your machine; the agent itself may call cloud models.
This distinction matters. Many "local-first" tools are really just "local UI + cloud model." OpenBot achieves genuine local-first: workspace, queue, browser, messaging—this infrastructure is all local; the model is merely invoked.
Why a Desktop App, Not a Web App?
OpenBot is an Electron app (macOS/Windows/Linux). Why not web?
Because the browser is the agent's tool, not the agent's container.
If OpenBot were a web app, the agent would need to control your Chrome via a remote debugging protocol—possible but clumsy. OpenBot embeds a browser the agent controls directly, without fighting your daily browser for windows.
More importantly, desktop apps can do things web apps can't:
From "Chat" to "Workspace"
Over the past two years, the dominant form of AI tools has been chat—an input box, an output area, conversation as work.
That form is breaking apart. Cursor embedded chat into the editor; Claude Code turned chat into a terminal; OpenBot turns chat into a desktop.
The trend is clear: what agents need isn't a bigger context window—it's a more persistent work environment.
Context windows solve "how much the agent can remember." Workspaces solve "what the agent can do." The former is memory; the latter is action.
OpenBot gives each agent a workspace, a browser, a message queue, and a model configuration—taken together, these turn the agent from "a machine that answers questions" into "a colleague sitting next to you."
Colleagues don't need to re-meet you at every meeting. Colleagues have their own desks. Colleagues can talk to each other. That's what OpenBot wants to do.
---
Project: https://github.com/nightly-labs/openbot Stars today: 794 Status: Developer preview, supports macOS / Windows / Linux