Computers and Software

OpenBot, How to Build Your Own Open-Source AI Coworker on Your Own Servers

OpenBot: Build Your Own Open-Source AI Coworker (Webinar)

Video: OpenBot: Build Your Own Open-Source AI Coworker (Webinar)

· based on the channel CopilotKit

OpenBot is an open-source, MIT-licensed platform from CopilotKit for building your own AI coworker — an agent with a defined role, persistent memory, its own computer and guardrails on what it is allowed to touch, all running on infrastructure you control. The project lives at github.com/CopilotKit/OpenBot, and the commercial version for teams, Soar, is open for early access registration with AI coworkers for every team on your own servers.

The idea is a deliberate step away from the "one giant chatbot" model. Instead of a single assistant that answers questions, OpenBot produces coworkers: narrow, named agents that hold a job, remember context between sessions, operate a sandboxed machine, and are explicitly fenced off from the systems they should not reach. That combination — role, memory, computer, guardrails — is what turns a language model into something that can be handed a recurring task.

What OpenBot actually is and how it differs from a chatbot

OpenBot is a self-hosted framework, not a hosted product, and that distinction drives most of its design decisions. A chatbot waits for a prompt and returns text; an OpenBot coworker is configured once with a role and then works against that role over time, using memory to carry state forward and a dedicated computer to run tools, browse, execute code or manipulate files.

Four properties define a coworker in the platform:

  1. Role — a scoped job description that shapes the system prompt, the available tools and the expected outputs.
  2. Memory — persistence across interactions so the coworker does not restart from zero on every request.
  3. Its own computer — an isolated execution environment where the agent can actually do things rather than only describe them.
  4. Guardrails — explicit limits on which files, services, APIs and data the coworker can reach.

Because the license is MIT, the code can be forked, audited and embedded in internal tooling without a commercial agreement. Because it is self-hosted, the model provider is a configuration choice rather than a vendor lock-in: teams point OpenBot at the provider they already have a contract with.

The CopilotKit and AGUI foundation underneath

OpenBot is built on CopilotKit's agent-to-UI stack, and the AGUI protocol is the piece that makes coworkers usable outside a terminal. AGUI standardizes how an agent streams state, messages and tool activity to a front end, which means the same coworker can surface in a web app, a chat panel or an internal dashboard without rewriting the integration for each surface.

For builders, this matters in practical terms: the agent logic, the interface layer and the deployment are separable. You can swap the model, change the UI framework or move the coworker to another server without touching the other two layers. That separation is also what allows the open-source core and the commercial Soar layer to share the same foundation while differing in governance features.

What Soar adds for business deployments

Soar is the paid, business-oriented edition of OpenBot, and its additions are almost entirely about control rather than intelligence. The agent capability is the same; what changes is what an administrator can see, approve and prove after the fact.

  • Runs on your servers with your choice of model provider, so data residency and procurement stay inside existing boundaries.
  • Admin rules and approvals for risky steps, meaning a coworker pauses for a human before an action with real consequences.
  • A full audit log of what each coworker did and which tools it invoked.
  • Surfaces where work already happens: Slack, Microsoft Teams, hundreds of apps through Composio, and approved MCP servers.
  • Enterprise identity and security plumbing: SSO, SCIM provisioning, and audit events streamed to your SIEM.
  • Distribution through the AWS Marketplace, which shortens the path through procurement for organizations that buy cloud software that way.

Soar was announced in early access, and the webinar accompanying the launch walks through the architecture, a live demonstration and a Q&A with the CopilotKit team — Nathan Tarbert, David McKay and Guido Vizoso.

Getting started with your first coworker

Starting with OpenBot follows a short, repeatable path, and the sensible first project is a narrow, low-risk task rather than a broad assistant.

  1. Clone the repository from GitHub and install dependencies following the project's setup instructions.
  2. Choose a model provider and supply credentials through environment configuration; the platform is designed to accept different providers rather than assume one.
  3. Define the role in plain language: what the coworker is responsible for, what a good output looks like, and what it must refuse.
  4. Set the guardrails before granting any tool access — decide which directories, APIs and services are in scope, and start with the smallest set.
  5. Give it a task with a clear finish line, such as triaging incoming issues, summarizing a document set or drafting status updates from a tracker, and inspect the audit trail of what it did.
  6. Add memory and integrations incrementally, connecting Slack, Teams or app connectors through Composio only once the basic loop behaves predictably.

A useful rule of thumb: if you cannot describe the coworker's job in two sentences and its boundaries in one, the role is still too broad for a first deployment.

Where OpenBot and Soar fit in an AI coworker strategy

The realistic pattern is to prototype on the open-source core and graduate to governance when a coworker touches production systems. During experimentation, the questions are about capability — can the agent do the task reliably, does memory help or hurt, which tools does it actually need. Once a coworker starts acting on real tickets, real repositories or real customer data, the questions shift to accountability: who approved this action, what exactly ran, and can that be shown to an auditor.

That is precisely the gap Soar fills, and it explains why approvals, audit logs, SSO and SIEM streaming appear in the commercial tier rather than the open core. Teams that already run strict identity and logging infrastructure will recognize SCIM and SIEM export as the difference between a demo and something that passes a security review.

Summary

OpenBot gives teams an MIT-licensed, self-hosted way to build AI coworkers that combine a role, memory, a dedicated computer and explicit guardrails, with model choice left to the operator. Soar layers business governance on top: admin rules, approvals for risky steps, a full audit log, Slack and Teams integrations, Composio app connectors, approved MCP servers, SSO, SCIM and SIEM streaming, plus AWS Marketplace availability. The practical path is to start with one narrowly scoped coworker on the open-source core, verify its behavior against the audit trail, and move to Soar when human approval and compliance evidence become requirements. This breakdown was based on the CopilotKit webinar on building an open-source AI coworker; for teams ready to move past prototyping, the Soar early access signup is the next step.

Key takeaways

  • OpenBot is an open-source, MIT-licensed platform from CopilotKit for building AI coworkers that run on your own infrastructure.
  • Each coworker gets a role, persistent memory, its own computer and guardrails limiting what it can touch.
  • Soar is the commercial layer: admin rules, approvals for risky steps, a full audit log, SSO, SCIM and SIEM streaming.
  • CopilotKit's AGUI protocol is the interface layer that connects agents to front ends and chat surfaces.
  • Soar is available in early access and listed on the AWS Marketplace.

Questions & answers

Is OpenBot free to use?

Yes. OpenBot is released under the MIT license by CopilotKit, so you can use, modify and self-host it without a commercial agreement. The paid edition, Soar, adds governance features such as admin rules, approvals, audit logs, SSO and SCIM provisioning for business deployments.

What is the difference between OpenBot and Soar?

OpenBot is the open-source core that lets you build AI coworkers with a role, memory, their own computer and guardrails on your own infrastructure. Soar is the business edition running on your servers with your choice of model provider, adding approvals for risky steps, a full audit log, Slack and Teams integration, Composio app connectors, approved MCP servers, SSO, SCIM and SIEM event streaming.

Which model providers can I use with OpenBot?

OpenBot is designed to be model-agnostic: you configure the provider rather than being locked to one vendor, and Soar explicitly runs on your servers with your choice of model provider. In practice this means you can keep using whichever provider your organization already has approved and contracted.

Can an OpenBot coworker take actions on real systems?

Yes, which is why guardrails are a core concept. Each coworker gets its own computer to execute tasks, but it is explicitly limited in what it can touch, and in Soar risky steps can require human approval while every action is written to an audit log.

Source: OpenBot: Build Your Own Open-Source AI Coworker (Webinar) · Markdown version

See also