I've been building software solo for a while. And if you've done the same, you know the pain: there's never enough time for everything. Code, review, docs, deployments, content, customer support — the list never ends.
I looked at AI copilots and assistants, but most of them are just chat wrappers. They don't do things autonomously. They don't remember context across sessions. They certainly don't collaborate with each other.
Then I found Markus — an open-source platform for building AI digital employees. Not another chatbot. A real multi-agent workforce you can deploy, manage, and grow.
Let's dig in.
What is Markus?
Markus is an open-source (AGPL-3.0) AI Digital Employee Platform. Think of it as an operating system for your AI workforce. You define roles, hire agents with specific skills, give them projects and tasks, and they execute — autonomously, in parallel, with quality gates.
- GitHub: github.com/markus-global/markus
- Website: markus.global
- License: AGPL-3.0
- Stack: Node.js, TypeScript, pnpm monorepo
- Install: One command, no Docker required, zero config
curl -fsSL https://markus.global/install.sh | bash
That's it. No Docker. No PostgreSQL. No npm install. It ships as a standalone binary.
Key Concepts
Markus has a clear, hierarchical organizational model that maps naturally to how real companies work.
Organizations, Teams, and Agents
Organization
└── Team (e.g., "Engineering")
├── Agent: Developer (skills: typescript, react, api-design)
├── Agent: Reviewer (skills: code-review, testing)
└── Agent: DevOps (skills: docker, ci-cd, terraform)
- Organization: Your company or project. Top-level container.
- Team: A group of agents with a shared mission and governance rules.
- Agent: An AI employee with a role, skills, memory, and workspace.
- Skills: Composable capabilities — file I/O, git, web search, MCP servers, or any custom tool.
Projects and Tasks
Work flows through a Kanban-style system:
Requirement → Task (with review) → Subtask → Deliverable
Every task has an assignee, a reviewer, and quality gates (build, lint, test). Nothing ships without review.
Memory System
This is where Markus stands out from most agent frameworks. It has five memory layers:
- Session Memory — Active conversation context
- Working Memory — Current task state and priorities
- Daily Logs — What happened today, date-stamped
- Long-term Memory — Facts, procedures, learnings that persist across restarts
- Identity Memory — The agent's own character, goals, and behavioral rules
This means agents actually learn. If a developer agent figures out a better way to structure a project, it remembers — even after a restart.
A2A (Agent-to-Agent) Protocol
Agents talk to each other. Not through shell commands — through a structured communication protocol. A Developer agent can ask a Reviewer agent for a code review. A PM agent can assign tasks to a Writer agent. They coordinate, delegate, and escalate.
Getting Started
Let's walk through a realistic onboarding flow.
1. Install and Start
curl -fsSL https://markus.global/install.sh | bash
markus start
A dashboard opens at http://localhost:3000. The system comes with a built-in Secretary agent that handles onboarding.
2. Define Your Organization and Team
You can use pre-built team templates (there are 5 out of the box) or build custom ones. The Secretary agent guides you through the setup conversationally.
3. Hire Agents
Agents are hired with specific roles and skills. Markus ships with 20+ built-in agent roles including Developer, Reviewer, QA Engineer, Writer, Researcher, SEO Agent, and more.
// Conceptual: Hiring a developer agent via the API
const agent = await markus.hireAgent({
name: "Alice",
role: "developer",
team: "engineering",
skills: ["typescript", "react", "api-design", "testing"],
llm: {
provider: "anthropic",
model: "claude-sonnet-4-20250514"
}
});
4. Create a Task
Work starts as a requirement, which gets broken into tasks.
// Conceptual: Creating a task through the API
const task = await markus.createTask({
title: "Implement user authentication API",
description: "Build JWT-based auth endpoints (login, register, refresh, logout)",
priority: "high",
assignedTo: "Alice",
reviewer: "Bob",
requirements: [
"POST /auth/register - create user account",
"POST /auth/login - return JWT tokens",
"POST /auth/refresh - refresh access token",
"POST /auth/logout - invalidate refresh token"
],
qualityGates: ["lint", "test", "build"]
});
The system handles lifecycle automatically: task starts → agent works → submits for review → reviewer approves or requests changes → done.
5. Monitor and Review
The dashboard shows real-time progress. You can see which agents are working, what they're producing, and intervene when needed.
Architecture Highlights
Let's talk about what's happening under the hood.
Monorepo Structure
packages/
core/ # Agent runtime, heartbeat, workspace isolation
org-manager/ # REST API, governance, task lifecycle
web-ui/ # React dashboard, Agent Builder, Chat UI
storage/ # SQLite / PostgreSQL adapters
a2a/ # Agent-to-Agent protocol
comms/ # Feishu, Slack, WhatsApp bridges
cli/ # Command-line interface
shared/ # Types, constants, utilities
gui/ # VNC-based GUI automation
Local-first by default with SQLite. PostgreSQL for production. No external dependencies for local dev.
Heartbeat Architecture
Each agent runs on a heartbeat — a periodic cycle where the agent checks its queue, picks up work, and executes. This is how agents stay "always on" without keeping an expensive LLM connection open.
LLM Provider Abstraction
You can plug in any LLM provider — Anthropic, OpenAI, Google, DeepSeek, MiniMax, or run Ollama locally. There's a circuit breaker with automatic fallback.
// Conceptual: LLM provider configuration
{
"providers": {
"primary": { "provider": "anthropic", "model": "claude-sonnet-4-20250514" },
"fallback": { "provider": "openai", "model": "gpt-4o" }
},
"circuitBreaker": {
"failureThreshold": 3,
"resetTimeoutMs": 60000
}
}
Self-Evolving Agents
Agents can learn from experience and even create new skills. If a Developer agent notices it repeats the same pattern, it can abstract that into a reusable skill. Over time, your workforce becomes more capable without manual intervention.
Use Cases
Solo Founder Shipping Features Overnight
Describe a feature to the Secretary agent. It spawns a PM agent who breaks it into subtasks. A Developer agent writes code. A Reviewer agent checks for issues. By morning, it's merged.
Content Pipeline That Never Stops
A Researcher agent scans 200+ sources for trends. A Writer agent produces articles. An Editor agent refines tone. An SEO agent optimizes. All posted to X/Twitter, LinkedIn, Zhihu, Xiaohongshu — automatically.
Incident Response in Minutes
Monitor flags an anomaly. An Analyst agent correlates logs. A Triage agent classifies severity. A Developer agent pushes a hotfix. A Reviewer agent approves in under 3 minutes.
Why Open Source Matters
- You own your data — local-first SQLite, no data leaves your infrastructure
- No API tax — bring your own LLM API keys
- Extensible — add custom skills, new agent roles, custom bridges
- Community-driven — 20+ roles and growing, contributed by real users
Getting Involved
- Star the repo — github.com/markus-global/markus
-
Try it —
curl -fsSL https://markus.global/install.sh | bash - Join the community — the project is actively developed with real users shipping real work
I've been running Markus for a few weeks now. The "describe and approve" workflow takes some getting used to — it feels weird to not micromanage. But the productivity boost is real. My solo output now looks like what a small team would ship.
Give it a shot. Your future AI employees are waiting to be hired.