An open-source operating system for running an AI agent company on your own machine.
Clone. Configure. Activate. Your 5-agent fleet goes to work in under an hour.
Agent Foundry materializes an AI agent company on your machine. Answer five questions about your business, and the system creates 5 specialized AI agents — a CEO, Chief of Staff, Head of Engineering, Head of Research, and Head of Marketing — each with their own identity, skills, memory, and tools.
They run on Hermes Agent profiles, communicate through Telegram, coordinate via a structured board + handoff protocol, and track progress against KPIs.
Your data stays on your machine. Your agents use your inference provider. You own the company.
I watched two separate production systems — 47 Industries' Pulse (a closed-source 4-agent company OS that replaced their first three hires) and WaveX-OS/Paperclip (an open-source 35-agent framework with 67K GitHub stars) — and realized:
| What they have | What's missing |
|---|---|
| ✅ Named agents with identities | ❌ Locked to specific platforms (macOS/Claude) |
| ✅ Structured handoff protocols | ❌ No Linux/systemd support |
| ✅ KPI measurement contracts | ❌ No Telegram-native comms |
| ✅ Kernel rules (verify-before-claim) | ❌ Not provider-agnostic |
| ✅ Bootstrap/ignition sequences | ❌ Complex setup (Docker, pnpm, launchd) |
Agent Foundry takes the best patterns from both and builds them on Hermes Agent — Linux-native, provider-agnostic, Telegram-first, zero Docker.
| Agent | Role | Heartbeat | Model | What They Do |
|---|---|---|---|---|
| CEO | Orchestration & Strategy | 30m | deepseek-v4-pro | Plans, delegates, decides. Runs the board. |
| Chief of Staff | Operations & KPIs | 30m | kimi-k2.6 | Tracks everything, flags problems early. |
| Engineering | Build & Ship | 60m | deepseek-v4-pro | Writes code, deploys, verifies. |
| Research | Market & Tech Intel | 120m | kimi-k2.6 | Knows the market, scouts technology. |
| Marketing | Growth & Launch | 60m | kimi-k2.6 | Gets people to care about what we build. |
Each agent has:
- SOUL.md — identity, authorities, responsibilities, decision framework
- KERNEL_RULES.md — non-negotiable rules loaded every heartbeat
- Skills — domain-specific procedures that improve with use
- Memory — persistent, learns from experience
- Telegram bot — the CEO (you) can spectate or advise via Telegram
Agents cannot claim work is done without independent verification. "Deployed to production" must come with: how you verified, what evidence you observed, and a timestamp. This prevents the most common agent failure mode — SDK-returns-200-but-nothing-happened.
Every task declares upfront: which KPI it targets, the expected delta, how it'll measure impact, and the baseline snapshot. Post-completion, the Chief of Staff grades every contract (A-F). Two consecutive D/F grades = board escalation.
Agents don't talk to each other directly. They file handoffs ({from}→{to}_{timestamp}.md) with context, state, deliverables, verification, and KPI impact. The CEO reads all handoffs and routes accordingly. No context loss. No "hey can you look at this."
You don't need 35 agents. For solo founders (pre-product stage): 5-agent kernel. As the company grows: expand to 6, hybrid, or formal 9. The roster shape is driven by your product state.
If an agent tries the same approach 3+ times, guesses without evidence, or builds without a clear user need → STOP. Write a board post. Wait for CEO reassignment. Spinning is more expensive than waiting.
- Linux machine with systemd
- Hermes Agent installed
- Inference provider (Ollama Cloud, Anthropic, OpenRouter — any)
- Telegram bot token (for operator communication)
- Git + GitHub
git clone https://github.com/milishiajay/agent-foundry.git
cd agent-foundry
cp company.template.yaml company.yaml
# Edit company.yaml with your detailsThe five pillars:
pillars:
identity:
product_description: "What are you building?"
target_market: "Who is it for?"
value_proposition: "Why should they care?"
infrastructure:
inference_provider: ollama_cloud
primary_model: deepseek-v4-pro
product_state: pre_product # drives roster shape
gtm:
lead_sources: [organic, product_hunt]
sales_motion: self_serve
comms:
primary_channel: telegram
operator_id: "YOUR_TELEGRAM_ID"# Create all 5 agent profiles
./runtime/bootstrap.sh mycompany
# Take initial KPI snapshots
./runtime/kpi-baseline.sh
# Activate the fleet
./runtime/activate.sh mycompanyIn under an hour, your 5-agent company is live. The CEO files its first board update. You watch via Telegram.
./runtime/health-check.sh
# ── Profiles ──
# ✓ mycompany-ceo (exists)
# ✓ mycompany-cos (exists)
# ...
# ── Gateway Services ──
# ✓ all running
# ── Resources ──
# ✓ GREEN: Disk/RAM nominalagent-foundry/
├── agents/ # Agent templates (one per role)
│ ├── _shared/
│ │ └── KERNEL_RULES.md # Rules loaded by every agent
│ ├── ceo/SKILL.md
│ ├── chief-of-staff/SKILL.md
│ ├── engineering/SKILL.md
│ ├── research/SKILL.md
│ └── marketing/SKILL.md
├── protocols/ # Inter-agent protocols
│ ├── HANDOFF.md # Structured handoff format
│ └── KPI_CONTRACT.md # KPI measurement contracts
├── runtime/ # Fleet lifecycle scripts
│ ├── bootstrap.sh # Create agent profiles
│ ├── activate.sh # Start all gateways
│ ├── stop-all.sh # Graceful shutdown
│ ├── health-check.sh # Fleet diagnostics
│ ├── kpi-baseline.sh # Initial KPI snapshots
│ └── reset.sh # Full reset to pre-ignition
├── workspace/ # Shared state (board, KPIs, handoffs, decisions)
│ ├── board.md # Live task board
│ ├── handoffs/ # Agent-to-agent handoffs
│ ├── kpi/ # KPI snapshots
│ └── decisions/ # Decision log
├── docs/
│ └── IGNITION.md # Full ignition sequence
├── company.template.yaml # Company definition template
├── company.yaml # Your company definition (gitignored)
├── README.md
└── LICENSE
┌─────────────────────────┐
│ YOU (Operator) │
│ Telegram spectator │
└───────────┬─────────────┘
│ board signals
┌───────────────────────────┼───────────────────────────┐
│ Agent Foundry Fleet │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ CEO │ │ Chief of │ │ Eng │ │
│ │ 30m beat │ │ Staff │ │ 60m beat │ │
│ │ v4-pro │ │ kimi-k2 │ │ v4-pro │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ │ │ │ │
│ └─────────────┼─────────────┘ │
│ │ │
│ ┌──────────┐ │ ┌──────────┐ │
│ │ Research │───────┼───────│Marketing │ │
│ │ 120m │ │ │ 60m beat │ │
│ │ kimi-k2 │ │ │ kimi-k2 │ │
│ └──────────┘ │ └──────────┘ │
│ │ │
│ ┌───────┴───────┐ │
│ │ Shared Board │ │
│ │ workspace/ │ │
│ │ ├ board.md │ │
│ │ ├ handoffs/ │ │
│ │ ├ kpi/ │ │
│ │ └ decisions/ │ │
│ └───────────────┘ │
└──────────────────────────────────────────────────────┘
| Pulse (47 Industries) | WaveX-OS (Paperclip) | Agent Foundry | |
|---|---|---|---|
| License | Closed, $1.5K+ | Apache 2.0 | MIT |
| Platform | Unknown | macOS (launchd) | Linux (systemd) |
| Agent count | 4 | Up to 35 (165 templates) | 5 (expandable) |
| Inference | Unknown | Claude Max (OAuth) | Any provider |
| Comms | NeuralOS (visual) | Web dashboard | Telegram |
| Docker | Unknown | No | No |
| Setup time | 2 weeks (service) | ~1 hour | ~1 hour |
| Self-healing | Unknown | 3-layer | systemd restart |
| KPI contracts | No | Yes (graded) | Yes (graded) |
| Handoff protocol | Custom | Board/issues | File-based structured |
| Verify-before-claim | No | Yes | Yes |
| Maturity | Production agency | v0.3 (371 commits) | v0.1 (just launched) |
Agent Foundry is not another agent framework. It's an organizational structure for agents — the operating system that sits above any single agent tool.
- It's the handoff protocol, not the agent itself
- It's the KPI contract, not the code
- It's the board and the decisions log, not the model
- It's the ignition sequence that turns "five profiles" into "one company"
The agents themselves can be swapped. The structure persists.
v0.1 — Minimal Kernel (just launched)
- 5-agent roster with full templates
- 8 kernel rules loaded every heartbeat
- Structured handoff protocol
- KPI measurement contracts with grading
- Bootstrap + activation scripts
- Health check diagnostics
- Monte Carlo simulation (Phase H)
- Reactflow fleet visualization
- Stripe billing integration
- Resource sweeper with auto-throttle
- Additional roster shapes (collapsed_6, hybrid, formal_9)
Agent Foundry is MIT licensed. Fork it. Modify it. Run your own company.
If you build something on it:
- Open an issue with your experience
- PR improvements to agent templates or protocols
- Share what your fleet built
Built on Hermes Agent by Nous Research.
Inspired by:
- Pulse by 47 Industries — proved the 4-agent agency model works in production
- WaveX-OS — open-sourced the company-generation wizard and Paperclip runtime
- Paperclip (67K ★) — the agent management runtime that WaveX-OS bridges into
- The Decision Book by Krogerus & Tschäppeler — 50 decision models that structure agent reasoning
The company is the product. The agents are the builders. The board is the source of truth.