GitHub - OtoDock/oto-dock: Your personal AI agent platform — self-hosted, BYO Claude/Codex subscription · GitHub

Skip to content

Navigation MenuSign inAppearance settingsPlatformAI CODE CREATIONGitHub CopilotWrite better code with AIGitHub Copilot appDirect agents from issue to mergeMCP RegistryIntegrate external toolsDEVELOPER WORKFLOWSActionsAutomate any workflowCodespacesInstant dev environmentsIssuesPlan and track workCode ReviewManage code changesCode QualityEnforce quality at mergeAPPLICATION SECURITYGitHub Advanced SecurityFind and fix vulnerabilitiesCode securitySecure your code as you buildSecret protectionStop leaks before they startEXPLOREWhy GitHubDocumentationBlogChangelogMarketplaceView all featuresSolutionsBY COMPANY SIZEEnterprisesSmall and medium teamsStartupsNonprofitsBY USE CASEApp ModernizationDevSecOpsDevOpsCI/CDView all use casesBY INDUSTRYHealthcareFinancial servicesManufacturingGovernmentView all industriesView all solutionsResourcesEXPLORE BY TOPICAISoftware DevelopmentDevOpsSecurityView all topicsEXPLORE BY TYPECustomer storiesEvents & webinarsEbooks & reportsBusiness insightsGitHub SkillsSUPPORT & SERVICESDocumentationCustomer supportCommunity forumTrust centerPartnersView all resourcesOpen SourceCOMMUNITYGitHub SponsorsFund open source developersPROGRAMSSecurity LabMaintainer CommunityGitHub StarsArchive ProgramREPOSITORIESTopicsTrendingCollectionsEnterpriseENTERPRISE SOLUTIONSEnterprise platformAI-powered developer platformAVAILABLE ADD-ONSGitHub Advanced SecurityEnterprise-grade security featuresCopilot for BusinessEnterprise-grade AI featuresPremium SupportEnterprise-grade 24/7 supportPricingSearch/Sign inSign upAppearance settings

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

Uh oh!

There was an error while loading. Please reload this page.

OtoDock

/

oto-dock

Public

Notifications
You must be signed in to change notification settings

Fork
3

Star
42

Code

Issues
0

Pull requests
0

Discussions

Actions

Projects

Security and quality
0

Insights

Additional navigation options

Code

Issues

Pull requests

Discussions

Actions

Projects

Security and quality

Insights

mainBranchesTagsGo to fileCodeOpen more actions menuLatest commit History43 Commits43 CommitsFolders and filesNameNameLast commit messageLast commit date.github.github  audioaudio  dashboarddashboard  mcpsmcps  phonephone  proxyproxy  satellitesatellite  scriptsscripts  .dockerignore.dockerignore  .gitattributes.gitattributes  .gitignore.gitignore  CHANGELOG.mdCHANGELOG.md  CODE_OF_CONDUCT.mdCODE_OF_CONDUCT.md  CONTRIBUTING.mdCONTRIBUTING.md  LICENSELICENSE  README.mdREADME.md  SECURITY.mdSECURITY.md  VERSIONS.mdVERSIONS.md  config.env.exampleconfig.env.example  docker-compose.build.ymldocker-compose.build.yml  docker-compose.phone.ymldocker-compose.phone.yml  docker-compose.t1.ymldocker-compose.t1.yml  docker-compose.ymldocker-compose.yml  ruff.tomlruff.toml  View all filesRepository files navigationREADMECode of conductContributingLicenseSecurityMore items

OtoDock — Collaborative Agents
The agentic company OS.

The brains of your company, built on Claude Code & Codex, working on your Anthropic and OpenAI subscriptions.

Docs ·
Install ·
Features ·
Discussions

Self-hosted · Multi-tenant by design · Fair source
Runs on  Claude Code · Codex · your API keys · local models

Dashboard highlights. The two-minute video tells the whole story.
If OtoDock is useful to you, a star on this repository helps other people find it.

Why OtoDock
OtoDock acts as the brain of your company. You create powerful agents that
connect to the tools your company runs on, work in departments, delegate to
each other, and keep working on their own when no one is watching. It is
multi-tenant by design. Many people work with the same agents, and there
are four modes that decide how an agent is shared and where its work lands.
You work with your agents on your self-hosted dashboard, or you can even
give them a phone line and talk to them. All of it runs on your own
Anthropic and OpenAI subscriptions, and on local models.
Build your own AI agents
Every agent gets a name and a job, like a Personal Assistant, a System Admin
or a Marketing Manager, and runs on your server. An agent is made of six
parts, and you can edit every one of them.

Persona. Plain-language instructions tell the agent who it is and how
it works.
Memory. The agent keeps its own notes across chats.
Workspace. The folder where the everyday work lands. It is private for
each person, shared by the whole team, or both, depending on the agent's
mode.
Knowledge. Reference documents are always on hand.
Skills. The agent learns techniques it can apply to its work.
Tools. The agent uses only what it is allowed to use.

Four ways to share one agent
Every agent has a mode that decides how people share it.

Mode
What it means

Personal only
A private workspace for each person.

Personal + shared
A private workspace for each person as the default, and a shared one for the team.

Shared + personal
A shared team workspace as the default for everyday work, plus a private one per person.

Shared only
Everyone shares one history and one workspace.

Everyone gets the right seat
Admins add each person to the agents they need.

Three platform roles
Three roles on every agent

An Admin runs the platform.
A Manager has full control of the agent.

A Creator creates agents.
An Editor edits the shared files.

A Member uses the agents they are given.
A Viewer chats and reads the shared files.

Claude Code or Codex. Your subscription.
Claude Code runs on your Anthropic subscription, and Codex runs on your
ChatGPT subscription. Every user connects their own subscription. Local
models on your own hardware work as well. You pick the engine per agent,
and you can switch it per chat.

They work while you are away
Agents run on any schedule, when a webhook event fires, or once at a time
you choose. They work in your workspace, where their reports, files and
updates land, and they notify you when something needs you. Notifications
come in four severities, from a quiet chime to a persistent danger alarm.
Every run is a full chat you can open, read and continue, so no one has to
be watching.

Give an agent a phone number
Agents answer and place phone calls. Bring your own Twilio account, or
connect the Asterisk or FreePBX server you already run.

Runs on your server. Works on your machines.
By default, all your agents run on your server, in an isolated sandbox, with
one dashboard controlling all of them. You can also pair a laptop, a
workstation or a PC running macOS, Linux or Windows with a one-line install.
The machine keeps a single outbound connection to your server, so it needs
no open ports, and its files stay in sync. The same agent then runs on that
machine with full access to it, and you work with it from the same
dashboard, anywhere. If the machine goes offline, your server takes over.

Your own cloud of agents.
The two-minute video

hero-v8-web.mp4

This entire video was directed, captured and edited by an OtoDock agent.
Watch it in full quality on otodock.io.
The company, running

Departments. Organize your agents into departments, decide who can delegate to whom, or put them in a meeting together.
Live dashboards. Every agent gets live dashboards, so you can manage them effortlessly.

Endless tools. Your agents are digital employees. They connect to endless tools, from your calendar to your smart home.
Documents. They edit Excel, Word and PowerPoint files right in the chat.

Artifacts. Agents answer with live, interactive UI, rendered right in the chat.
Meetings. Specialist agents discuss a topic together and converge on an answer, live in the dashboard.

Terminal. The Claude Code or Codex terminal opens in the dashboard, with the agent's tools already loaded.
Remote machines. The same agent, with all its tools and its synced workspace, runs on any machine you pair with one command, and it can use everything on that machine.

Locked down by default
Agents are powerful, so OtoDock assumes they can't be trusted. Every
server-side agent runs inside a kernel sandbox with always-on network
isolation, and you grant access one service at a time.

A kernel sandbox around every agent. Each session runs in its own
mount and process namespace. Folders are mounted automatically from each
user's role per agent.
Network isolation. Private ranges, your LAN, and cloud metadata
endpoints are unreachable by design. MCP tools that need a local service
can be granted scoped access by the admin, per agent.
Secure credentials. Credentials are encrypted at rest and injected
only per session. Agents can use them, but never see them.
Ready for teams. SSO sign-in, two-factor auth, and per-user cost
budgets come standard, from the first install.

Read the security model →
Everything included
One platform, the whole toolkit.

Memory that persists. Agents keep transparent, editable memory files,
per user and per agent.
Documents and files. Agents create and edit Word, Excel, PowerPoint
and PDF files, and every file opens in a live editor inside the chat.
Images. Agents generate and edit images in the chat, and a
professional-grade pipeline handles photo editing.
Video and audio. Agents generate footage and transitions, cut
timelines, add captions, voice-overs and music, transcribe audio and video
into text and subtitles, and produce speech and music of their own.
Web browsing. The browser tool from the community catalog lets agents
research the live web.
Built-in tools. Schedules, triggers, notifications, meetings,
delegation, phone calls, file transfer between agents, live charts and
mini-apps, SSH hosts, and browser and computer control on paired machines
all ship with the platform.
Community catalog. Ready-made agents, tools and skills install in one
click, with GitHub, Notion, Home Assistant, Nextcloud, Prometheus, UniFi
and Uptime Kuma among them, and more landing regularly.
Extensible by design. Any MCP tool server installs from a manifest,
and tools are assigned per agent.
Usage and budgets. Costs are tracked per user and per agent, with
weekly or monthly limits.
Team-ready security. SSO and OIDC, two-factor auth, per-agent roles,
encrypted credentials and scoped API keys come from day one.

See all features at otodock.io/features.
Quick start
A Linux server with Docker is all you need (4 GB RAM minimum, see the
sizing guide).
Create a folder for the install, then run the script in it:
mkdir otodock && cd otodock
curl -fsSLO https://raw.githubusercontent.com/OtoDock/oto-dock/main/scripts/install.sh
bash install.sh
The installer checks Docker, writes a .env with a generated database
password, handles the Ubuntu 24.04+ host step automatically when the host
needs it, downloads the release-pinned docker-compose.yml plus the
phone-service overlay, and starts the stack. Everything lands in the folder
you run it from. The script performs fresh installs only, and stops rather
than touch an existing install.
If your users browse to the server by name or IP, set DASHBOARD_PUBLIC_URL
in the generated .env. Behind a reverse proxy, also set TRUSTED_PROXY to
your proxy's IP
(reverse proxy & HTTPS).
Every optional knob is documented in the
Configuration reference,
and the installation guide
also covers building from source, bare-metal development, and running
behind a reverse proxy with HTTPS.
The first five minutes
Open http://localhost:8400 and the setup wizard greets you. Create the
owner account, and OtoDock installs the Personal Assistant for you, with the
tools it needs. Connect your Claude or ChatGPT subscription under Setup,
AI Engines, and the banner that reminds you goes away. Open the Personal
Assistant from the Agents page and send it your first message. Its reply
streams in live, with every tool call and every file it creates
(First run). From there
you add agents from the community catalog or build your own, and you add
the people who will work with them.
How it fits together
dashboard/ React dashboard — chat, agents, tasks, files, admin
proxy/ Platform core (FastAPI) — sessions, security, scheduling,
the agent sandbox, and the WebSocket hub the dashboard talks to
mcps/ MCP tool servers: OtoDock's custom set (files, memory, tasks,
meetings, notifications, …) + community mirrors
audio/ Speech package — STT / TTS / voice activity, provider-agnostic
phone/ Telephony daemon — live calls over Twilio or FreePBX/Asterisk
satellite/ Remote-machine agent — pairs your own hardware to the platform
scripts/ Install, compose, backup/restore, and maintainer tooling

Agents run as Claude Code / Codex processes inside per-session kernel
sandboxes, talk to their tools over MCP, and stream every step back to the
dashboard. PostgreSQL holds the platform state.
Community

Docs: docs.otodock.io
Website: otodock.io
Community agents: OtoDock/community-agents
Community MCPs: OtoDock/community-mcps
Community skills: OtoDock/community-skills

Contributions are welcome: see CONTRIBUTING.md. Security
reports: SECURITY.md.
License
OtoDock is fair source: licensed under the
Functional Source License, v1.1, with Apache 2.0 future grant
(FSL-1.1-Apache-2.0). You can use, run, modify, and redistribute it for
anything except competing with OtoDock commercially — and each version
automatically becomes plain Apache 2.0 two years after its release.
Self-hosting is free for up to 5 users. Growing teams
license by seats. Same software, signed key,
no feature gates on your data or your agents.
A note from the author
OtoDock started with Claude Code. I wanted to use it beyond the terminal
and connect it to my services. So I built the platform around that idea.
It has since become the place where my own agents work: large parts of
OtoDock were built, tested, and shipped by agents running on OtoDock.
It's fair source so you can run it the same way for your company, and you
can share your builds in the
discussions.
— Dimitris Mourtzis
AboutYour personal AI agent platform — self-hosted, BYO Claude/Codex subscriptionotodock.ioTopicsagent-platformai-agentsclaude-codecodexdockerllmmcpself-hostedResourcesReadmeLicenseCode of conductCode of conductContributingContributingSecurity policySecurity policyActivityCustom propertiesStars42 starsWatchers1 watchingForks3 forksReport repositoryReleasesPackagesUsed byContributorsLanguages

Footer

© 2026 GitHub, Inc.

Footer navigation

Terms

Privacy

Security

Status

Community

Docs

Contact

Manage cookies

Do not share my personal information

You can’t perform that action at this time.

OtoDock is presented as an agentic company operating system designed to serve as the central brain for an organization, built upon the foundation of Claude Code and Codex, utilizing subscriptions from Anthropic and OpenAI while accommodating local models and user-provided API keys. The platform is designed to enable powerful agents that can connect to existing company tools, operate across various departments, delegate tasks among themselves, and maintain autonomy while operating unsupervised. The system is inherently multi-tenant, meaning it is designed to accommodate multiple users working with shared agents, providing fair source under the Functional Source License with an Apache 2.0 future grant.

The structure of an individual agent is defined by six core components that can be edited: Persona, which defines the agent's identity and operating principles; Memory, which allows the agent to retain notes across interactions; Workspace, which serves as the dedicated folder for everyday work, configurable for personal or shared use; Knowledge, which provides access to reference documents; Skills, which represent the techniques the agent has learned to apply to its tasks; and Tools, which define the permitted external functionalities the agent can invoke.

To manage collaboration and access, OtoDock incorporates four distinct modes that dictate how agents are shared, including Personal only, Personal plus shared, Shared plus personal, and Shared only. Furthermore, permissions are managed through three platform roles: Admin, Manager, Creator, and Member, defining control over the platform, agent management, creation, and usage, respectively. This structure is underpinned by rigorous security measures, ensuring that server-side agents operate within kernel sandboxes with always-on network isolation and process namespace separation. Credentials are encrypted at rest and injected uniquely per session, preventing agents from accessing sensitive information they do not need.

The platform is highly extensible, allowing agents to connect to an extensive catalog of external tools and integrate custom Machine Control Protocol servers, which can be installed from manifests and assigned to specific agents. The platform also supports advanced functional capabilities, including the ability for agents to generate and edit various file types such as Word, Excel, PowerPoint, and PDF directly within a chat interface. Agents can also generate media, process audio and video, perform live web browsing, and utilize built-in tools for scheduling, notifications, delegation, and even telephony functions through integrations with services like Twilio or Asterisk.

The deployment of OtoDock requires a Linux server running Docker, with a minimum of four gigabytes of RAM recommended. The installation process is managed by a script that handles the setup, downloading necessary Docker Compose files, and initiating the entire stack, ensuring a fresh installation experience. The user interface is centered around a dashboard that provides live management for agents, tasks, files, and administrative controls. The underlying architecture involves several interconnected components, such as the React-based dashboard, the FastAPI platform core managing security and scheduling, various Machine Control Protocol servers, and specialized packages for speech processing and telephony interaction. Moreover, the system features remote machine capabilities, allowing agents to synchronize workspaces and tools across paired personal hardware, ensuring operational continuity even if a local machine becomes offline.

The philosophy behind OtoDock stems from the desire to extend the capabilities of language models beyond simple terminal interaction, allowing them to connect directly to external services and manage complex workflows. As noted by the author, Dimitris Mourtzis, the platform evolved from an initial concept using Claude Code to a full-fledged environment where agents themselves contribute to the development and testing of the system. This self-hosted, agent-driven approach emphasizes privacy, control, and reproducibility, positioning OtoDock as a unified environment for managing sophisticated, autonomous AI agents within a corporate or organizational setting.