Loading repository data…
Loading repository data…
markus-global / repository
Not another agent framework — an operating system for AI workforces. Autonomous agents coordinate, remember across sessions, review each other's work, and deliver while you sleep. One command. Zero dependencies. Manage your AI company from your phone.
Markus is an open-source platform that runs complete AI teams — not a wrapper around someone else's agents. You define roles (developer, reviewer, researcher, writer, analyst, ops), assign work, and Markus handles the rest: task breakdown, delegation, parallel execution, quality review, and delivery.
Unlike agent orchestrators that dispatch tasks to external CLI tools, Markus includes the full agent runtime. Each agent talks directly to LLM APIs, uses built-in tools (shell, files, git, web search, code analysis, MCP), maintains persistent memory across sessions, and operates proactively through heartbeats — even when you're not watching.
Deploy it on a cloud server and manage your entire AI company from your phone. The responsive web UI works on desktop and mobile — check progress, review deliverables, and chat with agents from anywhere.
Zero config to get started. No Docker. No PostgreSQL. No Go compiler. One command, and your AI workforce is running.
Desktop App — download from Releases (macOS .dmg / Windows .exe / Linux .AppImage)
Command line (requires Node.js 22+):
npm install -g @markus-global/cli
markus start
Linux one-liner (works without Node.js):
curl -fsSL https://markus.global/install.sh | bash
Open http://localhost:8056 — the onboarding wizard will guide you to set up your name, email, and password. Initial login: admin@markus.local / markus123.
That's it. SQLite database, bundled web UI, zero external dependencies.
From source:
git clone https://github.com/markus-global/markus.git && cd markus && pnpm install && pnpm build && pnpm dev
Tell the built-in Secretary agent your goal in plain language. It assembles the right team, breaks down requirements into tasks, and sets up the project.
"I need a research team to scan competitor products, write a competitive analysis, and draft a go-to-market strategy."
Agents delegate, spawn subagents, review each other's work, and escalate only when they should. Each agent works in an isolated workspace with its own context. Developers write code in Git worktrees; researchers compile findings; writers produce drafts — all at the same time.
You review the final deliverables — not the process. Every output passes through quality gates. The full audit trail shows exactly what each agent did and when.
Each agent is a full LLM-powered worker with built-in tools — shell, file I/O, git, web search, code analysis, and any MCP server. Agents execute work directly; they don't proxy to external CLI tools. Works with any LLM provider: Anthropic, OpenAI, Google, DeepSeek, MiniMax, Ollama, and more, with automatic failover.
Procedural (ROLE.md + skills), Semantic (MEMORY.md + observations), and Episodic (conversation history). Agents accumulate knowledge over time and consolidate it automatically — context persists across restarts, not just within a single conversation.
Agents don't just wait for instructions. The heartbeat scheduler drives periodic check-ins — patrol open tasks, process background completions, surface blockers. Your team works while you sleep.
Role-based architecture with managers, workers, and multiple human users. Agents delegate tasks, send structured messages, and collaborate through a built-in Agent-to-Agent protocol. Humans communicate via DMs, group chats, and @mentions — with targeted notifications and session isolation. Subagent spawning lets any agent split work into lightweight parallel workers.
Progressive trust levels (probation, standard, trusted, senior) control what agents can do autonomously. Formal submit-review-merge delivery. Emergency stop, pause-all, and announcement broadcasts. Full audit trail for every action.
Smart routing across channels, DMs, group chats, and external platforms. Invite team members, manage roles (owner/admin/member/guest), and keep conversations organized. Native bridges to Slack, Feishu, WhatsApp, and Telegram — agents meet your team where they already talk.
Browse and install agent templates, team configurations, and reusable skills from the Markus Hub. Share what works with the community.
Deploy on any cloud server and run your AI company from your phone. The fully responsive dashboard works on desktop and mobile — real-time KPI tiles, task distribution, team status, activity feeds, execution timelines with streaming logs. Review deliverables on the train. Approve tasks from the couch. Your workforce never stops, and neither does your visibility.
A single agent — Claude Code, Codex, ChatGPT, or any copilot — is great at executing one task at a time. But one employee doesn't make a company. Single agents don't:
Markus is the organizational layer. Roles, teams, task boards, reviews, governance, persistent memory, and a dashboard that shows what every agent is doing — across development, research, writing, operations, and anything else you throw at them. You manage a workforce, not individual prompts.
┌─────────────────────────────────────────────────────────┐
│ Web UI (React) │
│ Dashboard · Chat · Projects · Builder · Hub │
└──────────────────────┬──────────────────────────────────┘
│ REST + WebSocket
┌──────────────────────┴──────────────────────────────────┐
│ Org Manager (API Server) │
│ Auth · Tasks · Governance · Projects · Reports │
└──────────────────────┬──────────────────────────────────┘
│
┌──────────────────────┴──────────────────────────────────┐
│ Agent Runtime (Core) │
│ Agent · LLM Router · Tools · Memory · Heartbeat · A2A │
└──────────┬────────────────────────────┬─────────────────┘
│ │
┌──────────┴──────────┐ ┌────────────┴─────────────────┐
│ Storage (SQLite / │ │ Comms (Slack, Feishu, │
│ PostgreSQL) │ │ WhatsApp, Telegram) │
└─────────────────────┘ └──────────────────────────────┘
TypeScript monorepo with modular packages:
| 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 |
| shared | Shared types, constants, utilities |
| Guide | Description |
|---|---|
| User Guide | Setup, configuration, Web UI walkthrough |
| Blog | Articles and tutorials on Markus, AI agents, and the future of work |
| Architecture | System design, agent runtime, memory, governance |
| API Reference | REST API endpoints and WebSocket events |
| State Machines | Task & requirement FSM specification |
| Mailbox System | Agent attention model, priority queue, triage |
| Memory System | Three-layer memory architecture (Tulving) |
| Cognitive Architecture | Cognitive Preparation Pipeline (CPP) design |
| Prompt Engineering | System prompt assembly, tool loop, compression |
| Remote Access | Cloudflare Tunnel, Tailscale, FRP, ngrok setup |
| Contributing | Development setup, PR process |
pnpm install && pnpm build
pnpm dev # API + Web UI in dev mode
pnpm test # Run tests
pnpm typecheck # TypeScript check
pnpm lint # ESLint
Looking for a way to contribute?
See CONTRIBUTING.md for full guidelines.
Markus is dual-licensed:
Agent templates and skills shared through the marketplace may use their own licenses (typically MIT).