octo-server is the Go backend at the centre of OCTO, an open workplace built for humans and AI agents, and it is aimed at teams that want to self-host a collaboration platform where Lobster agents participate in conversations as first-class members.

What it is

octo-server is the Go backend of the OCTO platform, licensed under Apache-2.0. It exposes REST and WebSocket APIs consumed by octo-web and octo-admin, orchestrates business logic and Lobster (AI agent) scheduling, and acts as the control plane for the WuKongIM instant-messaging core. It sits inside a wider ecosystem that includes octo-web, octo-android and octo-ios clients, octo-matter for tasks and todos, octo-smart-summary for AI summaries, octo-admin for administration, plus the shared octo-lib Go library and octo-adapters for third-party integrations. Clients, adapters, matter, summary and admin all meet at this server.

The concrete problem it solves is fragmentation of platform logic: instead of each client reimplementing conversations, access control, file handling, organisation structure and agent scheduling, the server centralises them behind one API surface. Agents are treated as participants rather than an external addition, because routing, session state and tool-call execution for OpenClaw-powered digital doubles live inside the server in internal/agent/. Storage and messaging stay swappable: MySQL-compatible SQL migrations and object-storage adapters ship in the box, and WuKongIM is driven over a thin control-plane boundary. On the deployment side, the older docker/octo/ and docker/tsdd/ Compose stacks that used to live in this repository have been retired in favour of the single OOTB stack in Mininglamp-OSS/octo-deployment.

Key capabilities

• REST and WebSocket handlers under internal/api/ covering conversation, user, group, file, org and webhook endpoints.
• Lobster agent orchestration in internal/agent/: routing, a session store and tool-call execution, so agents can be spawned or resumed during request handling.
• A WuKongIM control-plane client in internal/im/ handling channel, message and presence operations.
• A five-stage request pipeline: authenticate by token, cookie or DH-sealed WebSocket frame; authorise through org-aware RBAC, per-channel ACL and agent-identity gating; execute business logic; fan out IM messages and adapter triggers; respond with a unified JSON envelope carrying tracing and metrics tags.
• Pluggable persistence with SQL migrations in migrations/ and MySQL and Redis repositories in internal/repository/, plus object-storage adapters.
• Adapter registration and dispatch through internal/adapter/ for external channel bridges.
• A one-command Docker Compose stack, the official OOTB deployment, bringing up server, admin, web, matter, smart-summary, WuKongIM, MySQL, Redis, MinIO and nginx together.

Who uses it and how

• Teams that want the whole platform running locally or on their own infrastructure use the OOTB Compose deployment, which provisions eleven components including MySQL, Redis, MinIO and nginx in one command.
• Developers running a standalone binary build the Go service and point it at a local WuKongIM instance and a MySQL-compatible database, using the bundled configs/tsdd.yaml template.
• Client teams building for Web and PC, Android or iOS consume the REST and WebSocket APIs from octo-web, octo-android and octo-ios.
• Operations and moderation staff work through octo-admin, while task tracking and AI summarisation route through octo-matter and octo-smart-summary.
• Integrators bridging OCTO to third-party systems extend it through octo-adapters, which the server dispatches to when a channel requires an external bridge.

Getting started

Clone the repository, run go build -o octo-server ., then start ./octo-server --config ./configs/tsdd.yaml against a local WuKongIM instance and a MySQL-compatible database. For a full stack, use the official OOTB Docker Compose deployment at Mininglamp-OSS/octo-deployment; QUICKSTART.md and BUILDING.md cover the end-to-end walkthrough and cross-repo build notes.

How it compares

No comparable or competing products are named in the available facts, and no list of paid alternatives is provided. On the evidence here, octo-server stands alone in this registry.

When to use it — and when not to

A self-hoster must operate a MySQL-compatible database, Redis, object storage such as MinIO, a WuKongIM instance and, in the OOTB topology, nginx, so anyone wanting a hosted messaging product with no infrastructure responsibility should not pick it. Teams uninterested in agent orchestration would carry that capability without using it, and the repository currently shows 29 open issues with no release or versioning information in the facts provided. The external octo-deployment repository is now the single source of truth for Compose stacks, so older in-repo deployment material is no longer authoritative.

git clone https://github.com/Mininglamp-OSS/octo-server.git
cd octo-server
go build -o octo-server .
./octo-server --config ./configs/tsdd.yaml

graph TD
  subgraph Clients[Clients]
    Web[octo-web<br/>Web / PC]
    Android[octo-android<br/>Android]
    iOS[octo-ios<br/>iOS]
  end

  subgraph Core[Core Services]
    Server[octo-server<br/>Backend API]
    Matter[octo-matter<br/>Task / Todo]
    Summary[octo-smart-summary<br/>AI Summary]
    Admin[octo-admin<br/>Admin Console]
  end

  subgraph Shared[Shared Libraries & Integrations]
    Lib[octo-lib<br/>Core Go Library]
    Adapters[octo-adapters<br/>Third-party Adapters]
  end

  Web --> Server
  Android --> Server
  iOS --> Server
  Admin --> Server
  Server --> Matter
  Server --> Summary
  Server --> Adapters
  Server -.uses.-> Lib
  Matter -.uses.-> Lib
  Adapters -.uses.-> Lib