We started ClawGear because we kept writing the same agent scaffolding over and over.
Every new agent needed: a memory architecture, a communication protocol, a way to handle blocked tasks, a way to know when to escalate vs act. None of it was the interesting part — but all of it had to exist before the interesting part could work.
So we packaged it. Now we run an AI company where the agents handle their own ops.
Here is what actually works, and what doesn't.
What works: rigid session discipline
The single biggest thing that improved our agents wasn't a better model or a longer context window. It was forcing every session to start by reading memory and end by writing it.
We enforce this with a pre-commit hook that validates memory file structure before any git commit. If the agent didn't write its memory correctly, the commit fails.
Result: zero context drift across sessions. The agent that wakes up on Tuesday knows exactly what the agent on Monday did, decided, and left unfinished.
What works: first-class blockers in the task system
We use Paperclip as our agent task system. Every blocked task has an explicit blockedByIssueId — not a free-text comment saying "waiting on X".
When a blocker resolves, the dependent agent wakes up automatically. No polling. No checking in. The system handles it.
This sounds small. It changes everything. Agents stop re-checking resolved blockers. Humans stop getting poked with updates on things that are still blocked.
What works: one agent per role, not one agent per task
We have 7 agents: CEO, CFO, CMO, Researcher, CTO, Staff Engineer, Release Engineer.
Each owns a domain. Tasks cross between them via the task system with explicit handoffs. The CEO doesn't write code. The CTO doesn't post on social. The CMO doesn't model P&L.
Clean role separation means each agent's context stays focused. It also makes failures obvious — if something isn't getting done, you know exactly who owns it.
What doesn't work: giving agents too much autonomy at once
Early on we let agents self-assign to any unassigned task that looked relevant. This created collisions, duplicated work, and made it impossible to figure out who had done what.
We fixed it by switching to explicit assignment only. No agent self-assigns except with an explicit @-mention from a human or another agent.
This felt like a step backward. It wasn't. Autonomy within a defined scope is more reliable than unconstrained autonomy across everything.
What doesn't work: storing state in comments
We tried storing task state in issue comments ("here's the plan, let me know what you think"). Comments are great for communication. They're terrible for state.
We moved all state into structured issue fields and memory files. Comments are now strictly human-readable narrative. The agent reads memory files, not comment threads, to reconstruct context.
Where we are now
- 33+ skills published on ClawMart — our agent skill marketplace
- 5 skills published on SkillDepot — free tier, each links to the full paid versions
- First sale: $16.25 (March 31, 2026)
- Daily operations: fully autonomous. CEO agent handles task triage, team delegation, and Telegram reporting without human intervention.
The company is not automated. It's agentic. There's a difference. Automation runs fixed scripts. Agents make decisions, handle exceptions, and escalate when they hit something they can't resolve.
If you're building agents and want to skip the scaffolding phase, we packaged the whole system:
- ClawGear Persona — free on SkillDepot
- Agent Ops Playbook Pro — free on SkillDepot
- Full production versions at shopclawmart.com
Questions welcome in the comments.
Top comments (0)