# Building AI Digital Employees with Markus: An Open-Source AI Workforce Platform > Source: > Published: 2026-05-21 16:21:01+00:00 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](https://github.com/markus-global/markus) - **Website**:[markus.global](https://www.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. ``` js // 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. ``` js // 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](https://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.