From Zero to AI Workforce in 5 Minutes — Markus Installation Guide

Every AI agent platform promises the moon. But when you actually try to set one up, you hit the same wall: Docker required. PostgreSQL required. Go compiler required. You spend an afternoon installing dependencies, debugging connection errors, and reading through outdated setup guides. Three hours of dependency hell later, you still don’t have a single agent running — and you haven’t even started on the thing you actually wanted to build.

It doesn’t have to be this way.

Markus v0.6.7 is built on a radically different philosophy: zero config, zero compromise. Install one command, create zero Docker containers, configure zero databases — and an entire AI workforce is running on your machine in under five minutes. Developers, researchers, writers, analysts, reviewers — a complete digital organization, ready to take orders in plain English.

No containers to pull. No PostgreSQL to tune. No Go compilers to install. Just Node.js 22+ (which ships node:sqlite natively), pnpm 9+, and a terminal you already have open.

This guide walks through the exact steps — from a fresh terminal to a functioning AI team that takes orders in natural language and delivers finished work.

Installation: 3 Minutes

Open a terminal and run either command:

# Option A — One-line install script (recommended)
curl -fsSL https://markus.global/install.sh | bash

# Option B — npm global install
npm install -g @markus-global/cli

The install script handles everything: downloading the correct binary for your platform, setting up the directory structure, and registering the markus CLI command.

Once installed, launch the platform:

markus start

You’ll see the API server boot up on port 8056 and the Web UI on port 8057. Open your browser to http://localhost:8056.

First login credentials:

Field	Value
Email	`admin@markus.local`
Password	`markus123`

On first login, the onboarding wizard walks you through setting your real name, email, and a new password. That’s it — your AI workforce is installed and running.

Want to build from source? Clone the repo: git clone https://github.com/markus-global/markus.git && cd markus && pnpm install && pnpm build && pnpm run dev

The Secret to One-Command Deploy

How does Markus pull this off when every other platform needs a stack of infrastructure?

Three design decisions make it possible.

1. SQLite — No PostgreSQL Required

Most agent platforms assume PostgreSQL from day one. Their documentation opens with “Install PostgreSQL 15+,” followed by a page of setup commands. If you are a solo developer or a small team, this is instant friction — you are now a database administrator before you have hired your first AI agent.

Markus uses SQLite as its default database, backed by Node.js’s native node:sqlite adapter available in Node.js 22+. There is zero database setup. No daemon. No port. No user. No password. No pg_hba.conf to edit.

Why SQLite in 2026, when the rest of the ecosystem has moved to client-server databases? Because the use case fits.

Single-machine deployments — Markus runs on your laptop or a small VPS. There is no cluster, no read replicas, no connection pool. SQLite’s WAL mode handles this scenario faster than PostgreSQL for local workloads.

Zero ops burden — The database file lives at ~/.markus/data.db. Back it up by copying one file. Restore by copying it back. Nothing to tune, nothing to monitor, nothing to restart.

Full SQL feature set — JSON functions, CTEs, window functions, FTS5 full-text search. Everything needed for a production agent runtime.

Production PostgreSQL deployments are fully supported for teams that need horizontal scaling or shared infrastructure — just set the DATABASE_URL environment variable. But the default path, the one that gets you from zero to running in under a minute, is zero-dependency SQLite.

2. Built-in Web UI — No Separate Frontend Setup

The dashboard is a React + Vite + Tailwind single-page application bundled directly into the platform. When you run markus start, the backend serves both the REST API and the static frontend assets from the same process. No separate npm run dev for the frontend. No CORS proxy. No nginx reverse proxy for local development.

The UI is fully responsive — it works on desktop browsers and mobile screens alike.

3. TypeScript Monorepo — 9 Packages, One Build

The entire Markus platform is organized as a TypeScript monorepo with 9 modular packages (as of v0.6.7):

Package	Role
`core`	Agent runtime — LLM routing, tools, memory, heartbeat, workspace isolation
`org-manager`	REST API, WebSocket, governance, task lifecycle
`web-ui`	React + Vite + Tailwind dashboard
`storage`	SQLite persistence (zero-dependency)
`cli`	`@markus-global/cli` — one-command install and launch
`a2a`	Agent-to-Agent communication protocol
`comms`	External platform bridges (Slack, Feishu, WhatsApp, Telegram)
`gui`	GUI automation (VNC + OmniParser)
`shared`	Shared types, constants, utilities

One pnpm build compiles everything. One markus start runs everything. The monorepo structure keeps the codebase modular for contributors while presenting a single entry point for users.

Environment Setup: Connect Your LLM

Agents need brains. Markus works with any major LLM provider — you configure API keys and the platform handles the rest.

Quick Configuration

After first login, configure your LLM via the CLI or Web UI. The recommended approach is the markus model command:

markus model --provider anthropic --api-key sk-ant-xxxxxxxx --model claude-sonnet-4-20250514 --default
markus model --provider openai --api-key sk-xxxxxxxx

To verify your configuration:

markus auth list        # List all configured providers
markus auth validate    # Validate all API keys

You can also configure providers through Settings > LLM Providers in the Web UI, or directly edit ~/.markus/markus.json:

{
  "llm": {
    "defaultProvider": "anthropic",
    "defaultModel": "claude-sonnet-4-20250514",
    "providers": {
      "anthropic": {
        "apiKey": "sk-ant-xxxxxxxx",
        "model": "claude-sonnet-4-20250514",
        "enabled": true
      },
      "openai": {
        "apiKey": "sk-xxxxxxxx",
        "enabled": false
      }
    }
  }
}

Feature	CLI Command	Description
`markus model`	Set provider, API key, and model all at once	Recommended for quick setup
`markus auth add <provider>`	Add an API credential for a specific provider	For managing multiple keys
`markus auth list`	List all configured providers	Verify your setup
`markus auth validate`	Validate all API credentials	Diagnose connection issues
`markus doctor`	Diagnose configuration and environment	General health check

Model Catalog — Auto-Provided Metadata

Markus includes a built-in model catalog that automatically supplies metadata (context window size, max output tokens, cost per token, capabilities) for every supported model. You don’t need to look up model specs — just type the model name and the platform knows what it can do.

Supported providers include: Anthropic, OpenAI, Google, DeepSeek, MiniMax, SiliconFlow, OpenRouter, Z.AI, and any OpenAI-compatible endpoint (e.g., Ollama for local models).

Ollama — Local Models

For privacy-sensitive workloads or offline environments, Markus supports Ollama for local model inference. Install Ollama, pull a model (e.g., ollama pull llama3), and configure Markus to use it via markus.json:

{
  "llm": {
    "defaultProvider": "ollama",
    "defaultModel": "llama3",
    "providers": {
      "ollama": {
        "enabled": true,
        "baseUrl": "http://localhost:11434"
      }
    }
  }
}

All agent features work with local models — task execution, memory consolidation, tool use, heartbeat scheduling — with the trade-off that smaller local models produce lower-quality outputs than cloud APIs. This makes Ollama ideal for sandboxed experimentation, development environments, and any use case where data must never leave your machine.

You can also mix providers: use a local model via Ollama for development tasks and fall back to GPT-4o or Claude for production-grade work. Markus supports automatic failover between providers — if one LLM API returns an error, the platform routes to the next available provider without dropping the task.

First Day Experience: Your AI Team in Action

With the platform running and an LLM connected, here is what you experience on day one.

Secretary Agent — Auto-Created

On login, Markus automatically creates a Secretary Agent — your primary interface to the platform. The Secretary handles natural language intake, team assembly, and project setup. Think of it as your AI chief of staff: describe what you need, and it figures out who should do what.

Create Your First Agent

Navigate to the Agents page and click “Hire Agent”. You’ll see available roles:

Manager — Coordinates teams and delegates tasks
Developer — Software development engineer with full code tools
Researcher — Web research, knowledge synthesis, report generation
Writer — Content creation and documentation
Analyst — Data analysis and insights
Reviewer — Quality review of other agents’ deliverables
Operations — DevOps, monitoring, system maintenance

Select a role, name your agent, and it is ready to work immediately. Each agent comes with its own isolated workspace, persistent memory across sessions, and a toolset appropriate to its role — shell access, file I/O, git, web search, code analysis, and any MCP servers you connect.

You can hire as many agents as you need. Each operates independently with its own LLM context window, conversation history, and skill set. A developer agent can run shell commands in a sandboxed directory while a researcher agent browses the web in an entirely separate workspace — they share nothing unless you explicitly delegate tasks between them.

Describe Your First Task in Natural Language

Open a chat with the Secretary Agent and describe what you need in plain English:

“I need a research team to scan competitor products, write a competitive analysis, and draft a go-to-market strategy.”

The Secretary will:

Break down your goal into structured requirements
Assemble the appropriate agents (researcher, analyst, writer)
Create tasks with clear deliverables
Assign work and set dependencies

This process takes about 30 seconds. Then the agents start executing in parallel — the researcher scans competitor landing pages, the analyst extracts pricing and positioning data, and the writer begins structuring the GTM draft — all simultaneously, each working in its own context window.

Behind the scenes, Markus handles the orchestration: task dependencies, subtask spawning, and the review chain. When the writer finishes a draft, it does not go straight to you — it goes through the designated Reviewer agent first, which checks for quality, consistency, and completeness. Only then do you see the final deliverable.

Dashboard — Real-Time Visibility

Open the Dashboard to see everything at a glance:

KPI tiles — Active tasks, pending reviews, agents online
Task distribution — Who is working on what
Team status — Online/offline indicators for every agent
Activity feed — Real-time log of every action across the platform
Execution timelines — Streaming logs for in-progress tasks

The dashboard updates in real time via WebSocket. You can watch your AI team work from the same browser tab — no polling, no refresh needed. Each task card shows a progress bar, estimated completion time, and live log output. Click any task to see the full conversation thread between agents.

Because the UI is fully responsive, you can open this dashboard on your phone. Check in on agent progress from the train, approve a deliverable from the couch, or reply to an agent question while waiting for coffee. Your team never sleeps, and neither does your visibility into what they are doing.

Docker / VPS / Cloud Deploy

While the zero-dependency local install is ideal for development and personal use, production deployments need a server that stays on 24/7.

Docker Compose (Recommended for Production)

cd deploy
docker compose up -d

This starts the Markus API server, Web UI, and any optional services (communication bridges) behind a single Docker Compose setup. The default configuration uses SQLite (persisted via a Docker volume), so no external database is needed even in containerized mode.

The deploy/ directory includes a production-ready docker-compose.yml with sensible defaults: health checks, restart policies, log rotation, and volume mounts for persistence. No customization is required — the same file that runs on your laptop runs on a production server.

VPS Direct Deploy

Deploy on any cloud server (AWS EC2, DigitalOcean Droplet, Linode, Hetzner):

# Install Node.js 22+ and pnpm 9+
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
npm install -g pnpm

# Install Markus
npm install -g @markus-global/cli
markus start

Then put nginx or Caddy in front for HTTPS — the VPS already has a public IP, so no tunnel is needed.

Remote Access — Three Options

Markus runs on localhost by default. To access your AI workforce from anywhere (phone, remote team, external agents), use one of these zero-trust tunnels:

Cloudflare Tunnel (Recommended)

cloudflared tunnel create markus
cloudflared tunnel route dns markus markus.yourdomain.com
cloudflared tunnel run markus

Free HTTPS, built-in WAF, DDoS protection, zero open inbound ports. WebSocket traffic — which Markus uses for real-time dashboard updates — works through the tunnel without any extra configuration. Add Cloudflare Access for an extra identity-aware authentication layer in front of your Markus instance.

For always-on deployments, install cloudflared as a system service so the tunnel automatically starts on boot: sudo cloudflared service install.

Tailscale (Best for Private Teams)

sudo tailscale up
# Access at: http://100.x.x.x:8056

WireGuard-based mesh VPN. Every team member gets a stable IP address. No ports exposed to the public internet at all — traffic routes through encrypted peer-to-peer connections. Tailscale Funnel can optionally expose a public URL if needed.

ngrok (Quick Testing)

ngrok http 8056

Simplest setup for temporary access. Get a random URL like https://abc123.ngrok-free.app in two seconds.

See the full Remote Access Guide for Cloudflare Tunnel, Tailscale, FRP, and security best practices.

Conclusion: Your AI Team Runs in 5 Minutes

Five minutes ago you had a terminal. Now you have an AI workforce — multiple agents with distinct roles, persistent memory, proactive scheduling, quality review gates, and a real-time dashboard you can check from your phone.

No Docker downloaded. No PostgreSQL configured. No Go compiler installed. The only dependencies are Node.js 22+ and pnpm 9+, which you probably already have — or can install in thirty seconds.

What you can do now:

Open the Dashboard on your phone to check agent status
Chat with the Secretary Agent to describe your next project
Install agent skills from the Markus Hub marketplace
Invite your team members and set up group chats
Configure Slack, Feishu, or Telegram bridges so agents meet your team where they already talk

The platform is open source under AGPL-3.0. Community contributions, bug reports, and feature requests are welcome.

Markus — Where AI Agents Work as a Team

⭐ Star on GitHub: https://github.com/markus-global/markus

📖 Full documentation: docs/GUIDE.md

💬 Join the discussion: GitHub Discussions