Zenith Team

Run a company of AI agents that plan the work, do it on your own computer, and report back.

Docs · Self-hosting · Roadmap · Contributing · Security

What is Zenith Team

Zenith Team is a workspace where you run a company of persistent AI agents. You set the goals. A CEO Agent and its team propose a plan, you review it, and the work becomes tasks that go to the right agent.

It has two parts:

• The server is written in Go. It owns the product state: companies, agents, tasks, conversations and run history.
• The daemon runs on your own machine. It picks up work and runs it through the Codex CLI you already use, then streams the results back. Your provider sign-in never leaves your machine.

You use it from the web app or the desktop app.

Privacy. The server sends no telemetry. Everything it sends, and to whom, is listed in Privacy and network.

Status

Zenith Team is pre-1.0. A release can include breaking changes, so read the release notes before you upgrade.

The product's earlier name was retired in a clean break. Desktop apps, sign-ins and daemons from before the rename do not carry over: install the current release and sign in again.

Features

• A team of persistent agents. Each agent has its own role and instructions, and reports to a CEO Agent. → Agents
• Plans you can review. Agents propose task changes as a Company Plan. → Company Plan
• Clear ownership. Every task names the person who owns it and the agent that does the work. → Tasks
• Work runs on your computer. Each run uses your own agent CLI, inside a managed workspace. → Daemon and runtimes · Workspaces
• You stay in the loop. Agents ask you for approvals and answers instead of guessing. → Approvals and questions
• Schedules. Set up one-off or recurring agent work. → Schedules
• Ready-made workflows. Fill in a short form, pick an agent, and it runs as a normal task. → Workflows
• Plugins. The Workflow catalog and managed tools such as Zenith Studio are released from a separate repository and pinned here. → zenith-team-plugins

Get started

Self-host with Docker

You need Docker with Docker Compose, make, git and openssl.

git clone https://github.com/Intelligent-Internet/zenith-team.git
cd zenith-team
make selfhost-env   # create deploy/.env with generated secrets
make selfhost-up    # start PostgreSQL, Redis, Silo storage, the API server and the web app

Open http://localhost:8080 and create your account. The web app also passes API requests through to the server. To stop everything, run make selfhost-down.

Next steps:

• SELF_HOSTING.md: the short guide, including how to connect a computer that runs agents and how to open the server to others.
• Environment variables: every setting in deploy/.env.
• Security model: what the server protects, and what runs on your machines.

Desktop app: build from source for now

The desktop app starts its own daemon, so it connects your computer with nothing else to run. There is no ready-made download yet: each build has its server's address built in, so you build it for your own server.

cd frontend
pnpm install
ZENITH_TEAM_DESKTOP_PROD_ORIGIN=https://zenith.example.com pnpm electron:make

The unsigned installers land in frontend/out/make. See Desktop app for unsigned-build warnings, updates and uninstalling.

From source (dev loop)

Use this to work on the code. Install the tools listed under Development first; make doctor checks them.

cd frontend && pnpm install && cd ..   # once: frontend/ is its own pnpm workspace

make dev         # PostgreSQL, Redis and Silo in Docker, then the API (:8788) and the desktop app

The desktop app opens once the API is ready; create an account there. For the web app instead, run make dev DEV_DESKTOP=false and open http://localhost:5173. Prefer one terminal per process? Run make infra-up, make server and make desktop (or make frontend) separately.

Already run PostgreSQL, Redis and S3-compatible storage yourself? Run cp server/.env.example server/.env, point it at your services, and use make server-local instead of make server.

To run agents, start a daemon. It needs codex on your PATH:

make zenith-team-mcp-dev   # build the agent tool server into .dev/bin
cd server
go run ./cmd/zen auth login --server http://127.0.0.1:8788
ZENITH_TEAM_MCP_EXECUTABLE="$PWD/../.dev/bin/zenith-team-mcp" go run ./cmd/zen daemon start

The full walkthrough is in docs/quickstart.md.

Supported agent CLI

Zenith Team runs agents through the Codex CLI. Install and sign in to it yourself; Zenith Team never holds your provider credentials.

Agent CLI	Command	How Zenith Team runs it
Codex	codex	A codex app-server process, over JSON-RPC

Sessions, skills, models and usage are in Providers. Support for more agents, including Claude Code, OpenClaw, Pi, OpenCode and Hermes Agent, is on the roadmap.

Documentation

I want to…	Start here
Learn the main ideas	Core concepts
Get to my first finished task	Quickstart
See what happens when an agent runs	How Zenith Team works
Host Zenith Team myself	SELF_HOSTING.md
Connect my computer	Daemon and runtimes
Use the zen CLI	CLI reference
Understand the code	Architecture
Run the stack locally	Local development quickstart
Fix a problem	Troubleshooting
Contribute a change	CONTRIBUTING.md

All product docs live in docs/content/docs; the docs index explains the layout.

Architecture

 ┌────────────┐  ┌──────────────┐
 │  Web app   │  │ Desktop app  │
 └─────┬──────┘  └──────┬───────┘
       └───────┬────────┘
               │ HTTP + WebSocket
    ┌──────────▼─────────┐      ┌───────────────────────┐
    │   Go API server    │─────▶│ PostgreSQL  (state)   │
    │  companies, tasks, │─────▶│ Redis       (realtime)│
    │  runs, permissions │─────▶│ S3 storage  (files)   │
    └──────────▲─────────┘      └───────────────────────┘
               │ claims runs, streams results back
┌──────────────┴────────────────────────────┐
│ Your machine                              │
│   zen daemon ──▶ codex CLI                │
│   provider sign-in stays on this machine  │
└───────────────────────────────────────────┘

The server is the only writer of product state. The daemon claims queued runs, prepares a workspace, starts the agent CLI and sends back each finished step. Read ARCHITECTURE.md for the full picture.

Development

Tool	Version
Go	1.26 (server/go.mod)
Node.js	24 (.nvmrc; Electron needs 22.12 or newer)
pnpm	9.14.2, pinned in frontend/package.json (run corepack enable)
Docker	For the local PostgreSQL, Redis and Silo stack, and the integration tests

Path	What it holds
server/	Go module: API server, zen CLI and daemon, zenith-team-mcp, migrations
frontend/	Web app and Electron desktop app (its own pnpm workspace)
docker/	Local development stack
deploy/	Self-hosting and production files
docs/	Product docs, API contract, decision records

The main checks:

make go-unit                            # Go build, vet and unit tests (no Docker)
make lint typecheck                     # frontend checks
make api-lint api-types-check           # OpenAPI contract and generated types

Run make help to see every target. AGENTS.md holds the engineering rules.

Contributing

Contributions are welcome. Read CONTRIBUTING.md before you open a pull request. The roadmap shows what comes next and where help is wanted. New or changed Workflows go to zenith-team-plugins instead. Everyone taking part follows our Code of Conduct. Questions go to GitHub Discussions; see SUPPORT.md.

Security

Please do not report security problems in public issues. Follow SECURITY.md to report them privately.

License

Zenith Team is released under the MIT License. Third-party components keep their own licenses, including the free Iconsax icons in the app; see THIRD_PARTY_NOTICES.md.