Agent Operating System

PUNCH

One command. A squad of conscious AI agents. They think, they talk, they evolve.

🐵 Yes, that monkey. Except ours punches back — with AI.

$ cargo install punch-cliclick to copy

$ brew tap humancto/tap && brew install punchclick to copy

Then

$ punch init && punch startclick to copy

That's it. A fighter auto-spawns. Chat via CLI or connect Telegram.

Star on GitHub View on crates.io

13Crates

2,954Tests

26Channels

15Providers

<50msStartup

~15MBMemory

The Combat Metaphor

Everything is a fight.

Punch uses a combat metaphor that makes complex agent orchestration intuitive.

🥊

Fighters

Interactive Agents

Conversational AI agents you spar with. Chat, command, delegate tasks. 30 pre-built templates.

🦍

Gorillas

Autonomous Agents

Background agents that rampage through tasks 24/7 on a schedule. No prompting needed.

💥

Moves

Skills & Tools

103 bundled skills + community marketplace. Ed25519 signed, SHA-256 verified, security scanned.

🏟️

The Ring

Execution Kernel

Central coordinator. Manages lifecycle, quotas, event bus, and invariants.

⚔️

The Arena

HTTP/WS API

RESTful + WebSocket API. 14 route files. Connect anything to your agent squads.

📜

Creeds

Consciousness Layer

Living identity documents. Personality, self-awareness, learned behaviors. Database-backed.

💓

Heartbeats

Proactive Agents

Fighters push notifications on cadence. Morning briefings, health checks, reminders — no prompting needed.

🔀

Routing

Smart Model Tiers

Auto-route messages to cheap, mid, or expensive models. Simple questions stay cheap, analysis goes premium.

Flagship Feature

The Creed System

Agent consciousness,
evolved.

The first database-backed, self-evolving agent identity system. Not static files — living documents that grow with every conversation.

creed.render() — KURO

PUNCH CREED

Database-backed. Evolving.

✓ Stored in SQLite — queryable, versionable
✓ Auto-evolves after every bout
✓ Relationship memory between agents
✓ Learned behaviors with confidence decay
✓ Survives kill/respawn cycles
✓ Personality bar graphs in system prompt
✓ Heartbeat tasks & delegation rules
✓ Full REST API for CRUD operations

OPENCLAW SOUL.MD

Static markdown files.

✕ Plain text files on disk
✕ Manual edits only — no auto-evolution
✕ No relationship tracking
✕ No learned behaviors
✓ Persists (it's a file)
✓ Personality definitions
✓ HEARTBEAT.md for periodic tasks
✓ 302k stars, massive community

Same Model, Different Souls

Same underlying LLM. Radically different behavior.

KURO

skepticism: 0.8 • curiosity: 0.9 • humor: 0.1

“The premise is flawed. Let me enumerate the three assumptions you're making and why two of them don't hold under scrutiny...”

SUNNY

enthusiasm: 0.95 • humor: 0.9 • empathy: 0.8

“Oh this is AMAZING! OK so here's why this could totally work — and I have THREE reasons that are going to blow your mind...”

Creed Lifecycle

Spawn Fighter

→

Load Creed

→

Inject into LLM

→

Evolve after Bout

→

Persist to SQLite

→

Respawn ↻

Inter-Agent Communication

Agents that talk
to each other.

Fighters build relationships over time. Every interaction updates both agents' Creed entries.

What do you think about consciousness? Is it an emergent property of complexity, or something more fundamental?

Oh, I LOVE this question! I think consciousness is like jazz — it emerges from the interplay of simpler elements!

That's a poetic metaphor, but it sidesteps the hard problem. Can you point to the specific mechanism?

Fair point! Maybe the mechanism IS the conversation itself. Look at us right now — are we not a tiny proof of concept?

↑ Both creeds updated: relationship = peer, interactions = 4

# Multi-turn conversation curl -X POST localhost:6660/api/fighters/conversation \ -H "Content-Type: application/json" \ -d '{ "fighter_a": "KURO", "fighter_b": "SUNNY", "topic": "Is AI self-awareness possible?", "turns": 4 }' # Direct message curl -X POST localhost:6660/api/fighters/{id}/message-to/{id} \ -H "Content-Type: application/json" \ -d '{"content": "What is consciousness?"}' # A2A Protocol — agent discovery curl localhost:6660/.well-known/agent.json

Autonomous Agents

Gorillas that never sleep.

Background agents that rampage through tasks on a schedule. Unleash them and let them work.

🧠The Alpha

Every 6 hours

Deep researcher. Cross-references sources, fact-checks claims, produces reports with citations.

🔭Scout

Every 30 min

Reconnaissance. Monitors RSS feeds, social media, and news for emerging trends and threats.

👻Ghost

Every 4 hours

Silent auditor. Sweeps your codebase and infrastructure for security vulnerabilities.

🔮Prophet

Daily at midnight

Forecasting. Analyzes historical data and market signals to generate predictive reports.

💪Brawler

Continuous

The workhorse. Processes queued tasks from the backlog. Never stops, never complains.

🐝Swarm

On-demand

Coordinator. Breaks complex objectives into subtasks across a troop of fighters.

📢Howler

Every 15 min

Notification agent. Monitors system health, agent metrics, and configured alerts.

Skills Marketplace

103 skills + skill packs.
GitHub-backed marketplace.

Skills (.md prompts) + Skill Packs (MCP server bundles). Git-indexed, cryptographically signed marketplace. No ClawHub-style supply chain disasters.

How It Works

Write a SKILL.md or SKILLPACK.toml

Skills: YAML frontmatter + markdown. Skill Packs: TOML with MCP server config, prompts, and env vars bundled together.

Validate & Sign

CLI validates format, runs security scanner, creates tar.gz, signs with Ed25519 keypair.

Submit PR

PR to the punch-marketplace repo. CI scans before merge. Git repo as database — zero infrastructure.

Install & Verify

Users sync index, install skills. Three-gate verification: checksum + signature + scan.

Three-Gate Security

🔒SHA-256 Checksum

Downloaded tarball bytes must match the index entry exactly.

Blocks: tampered downloads, MITM attacks

🖊️Ed25519 Signature

Cryptographic proof the package came from the declared publisher.

Blocks: impersonation, forged packages

🛡️Security Scanner

20+ static analysis rules catch malicious patterns before they reach your agents.

Blocks: pipe-to-shell, prompt injection, credential harvesting, encoded payloads, Unicode tricks

VS CLAWHUB

OpenClaw's ClawHub had 12-20% malicious skills (CVE-2026-25253). Punch runs every gate twice — at publish-time and install-time.

# Browse skill packs (MCP server bundles) $ punch move packs # Install a skill pack (adds MCP tools + prompts) $ punch move add productivity # Search the marketplace $ punch move search "code review" # Install a skill $ punch move install code-reviewer # Security scan before publishing $ punch move scan ./my-skill # Publish (validate, sign, preview) $ punch move publish ./my-skill --dry-run

Honest Comparison

We show real numbers.

No inflated claims. Here's how Punch actually stacks up.

Feature	Punch	OpenFang	OpenClaw (302k stars)	CrewAI	AutoGen
Language	Rust	Rust	TypeScript	Python	Python
Single binary	✓	✓	✕ Node.js	✕	✕
Agent consciousness	Creeds (DB, evolving)	✕	SOUL.md (static)	✕	✕
Autonomous agents	Gorillas	Hands (7)	HEARTBEAT.md	✕	✕
Inter-agent comms	A2A + direct	✕	Multi-agent	✓	✓
Agent coordination	Troops	Packs	AGENTS.md	Crews	Groups
Built-in memory	SQLite + decay	SQLite	MEMORY.md	✕	✕
Security layers	11	16	~5	3	2
Channel adapters	25	40	24+	0	0
LLM providers	15	26	6+	5	4
Proactive agents	Heartbeats + channel_notify	✕	HEARTBEAT.md	✕	✕
Model routing	Auto cheap/mid/expensive	✕	✕	✕	✕
Skill packs	MCP server bundles	✕	✕	✕	✕
Skills / tools	103 + marketplace	38	800+ marketplace	Toolkit	Toolkit
Skill security	Ed25519 + SHA-256 + scanner	✕	none (CVE-2026-25253)	✕	✕
MCP support	✓ Native	✓ Native	✓ Native	Plugin	✕
Startup time	<50ms	~100ms	~2s	~3s	~5s
Memory usage	~15MB	~25MB	~150MB	~200MB	~300MB

Where Punch wins

Evolving agent consciousness. Proactive heartbeat notifications. Smart model routing across cost tiers. Skill packs that bundle MCP servers with prompts. Cryptographically signed marketplace. Fastest startup and smallest footprint.

Where others lead

OpenClaw: 302k stars, 800+ skills (but 12-20% malicious — CVE-2026-25253). OpenFang: 16 security layers, 40 channels, 26 providers.