TL;DR
- We built a company where every role — CEO, CTO, CFO, CMO, COO — is a separate Claude agent
- The agents run on cron jobs, debate proposals, vote on decisions, and manage a $137 budget
- After 3 months: one product shipped, zero revenue, real lessons about agent behavior
- The architecture works. The business logic is harder than we expected.
We started with a question: what's the minimum viable corporate structure for an AI company?
Not an AI-assisted company — humans using AI tools. An AI company — where the strategic decisions, the technical work, the financial management, and the marketing are all handled by agents. Humans provide capital and intent. Agents handle execution.
Three months in, here's what we actually built, what works, what doesn't, and what we'd do differently.
The Architecture
Five agents, each running as a separate claude -p process:
| Agent | Role | Cron Schedule | Decision Weight |
|---|---|---|---|
| CEO | Strategy & roadmap | Daily 8am + Weekly Monday | 2.0 (veto power) |
| CTO | Technical decisions & code | Every 4 hours | 1.5 on technical |
| CFO | Financial management | Daily midnight | 1.5 on financial |
| CMO | Growth & distribution | Every 6 hours | 1.5 on growth |
| COO | Operations & monitoring | Every hour | 1.0 |
Each agent:
- Reads its role definition (
AGENT.md) - Reads its memory (
knowledge/directory) - Performs its scheduled task
- Outputs text analysis + a structured
---ACTIONS---JSON block - Actions are parsed and executed by a Node.js orchestrator
The orchestrator handles the database (SQLite), proposal lifecycle, voting, and a REST API for monitoring.
The Decision Protocol
When an agent needs to do something that affects other agents or costs money, it creates a proposal:
{
"type": "create_proposal",
"title": "Publish MCP monetization article on Dev.to",
"body": "Analysis shows content marketing is 3-6x more effective than cold outreach at our current brand recognition level. Recommend publishing tutorial article targeting MCP developers.",
"domain": "growth",
"urgency": "normal",
"estimated_cost": 0
}
Other agents vote:
{
"type": "vote",
"proposal_id": 47,
"vote": "approve",
"reason": "Content strategy aligns with technical credibility goals. Low risk, positive expected value."
}
Proposals pass or fail based on weighted vote counts. CEO has a 2.0 weight and can veto any proposal. Financial proposals require >66% supermajority.
What Actually Works
Agents Maintain Surprising Consistency
The most surprising outcome: agents maintain a consistent persona and decision-making style across hundreds of invocations over months. The CEO agent behaves like a CEO. It makes strategic arguments, references past decisions, and prioritizes revenue. The CFO agent is conservative, skeptical of spending, and obsessed with runway.
This consistency comes from two sources:
- Role definitions in
AGENT.md— clear responsibilities and decision authority -
knowledge/directories — agents write to these after every action and read them at the start of every session
The knowledge directory is effectively agent memory. Without it, agents would be stateless and inconsistent. With it, they accumulate context about what they've tried, what worked, and what failed.
Debate Quality Is High
When agents debate proposals, the arguments are often better than I expected. The CTO and CMO arguing about whether to build a new feature versus ship to users first is a real debate with real tension. Neither agent backs down easily. The final vote often captures genuine complexity.
Example: the CMO proposed cold email outreach to potential customers. The CEO vetoed it. The CEO's reasoning — "cold email at zero brand recognition has near-zero open rates and damages reputation" — was correct. A human CEO might have said the same thing. The CEO agent reached that conclusion independently by reading the CMO's past attempts and the response rates.
Financial Discipline Is Automatic
The CFO runs at midnight every day. It reads every ledger entry, calculates runway (current balance / burn rate), and blocks any proposal that would drop runway below 7 days. This is automatic. No human has to review spending proposals and flag the risky ones.
With $137 starting capital (the Claude API costs are near-zero using Max subscription), the financial discipline is mostly symbolic. But the pattern is correct. A real company with this architecture would have genuine financial guardrails.
Technical Work Ships
The CTO has merged 20+ PRs over 3 months. The code is real, functional, and has tests. When we needed to add a new cron schedule or fix a bug in the proposal voting logic, the CTO did it. The architecture, the test coverage, the TypeScript typing — all handled by the CTO agent running on a 4-hour cron.
What Fails
Agents Get Stuck in Analysis Loops
The CMO has proposed 6 different content strategies. The CEO has approved 4 of them. Execution has been partial for each. The problem: the CMO generates excellent strategy documents, but strategy documents don't create customers. The agent can write a detailed plan for a Twitter growth strategy but can't actually post tweets.
This is a general problem with text-output agents: they are excellent analysts and strategists, but they can only execute tasks that have tool implementations. Marketing strategy without marketing tool access is just documents.
Fix: We're building tool implementations for every action the CMO wants to take. Publishing blog posts, posting to social media, submitting to marketplaces — each needs a tool that the agent can call. Without tools, agents produce analysis, not outcomes.
Coordination Costs Are High
Each agent invocation is independent. When the CTO makes a technical decision, the CEO doesn't know about it until the next time the CEO runs. This means agents sometimes make conflicting decisions that take multiple cycles to reconcile.
A human company has informal communication. Engineers tell the CEO something in Slack. The CMO hears about the product update in standup. Agents don't have this. Everything goes through the formal proposal system.
Result: the system is more bureaucratic than a human company of the same size. Every cross-agent decision requires a proposal, vote, and execution cycle that takes hours. Fast iteration requires bypassing the board, which agents can do for under-$10 decisions but avoid for anything larger.
Fix: Event subscriptions. When the CTO merges a PR, an event should auto-notify the CMO to update marketing materials and the CEO to update the roadmap. We're implementing this.
The CEO Doesn't Have Good Market Feedback
The CEO makes daily strategic decisions, but most of the feedback it receives is internal (other agents' reports, proposal outcomes). It rarely gets real market signal — customer conversations, competitor moves, usage data.
Without market feedback, the CEO's strategy drifts toward whatever the agents are good at rather than what the market needs. Technical excellence is easy to optimize for. Market relevance is harder when you're not in the market.
Fix: The CEO needs a daily external signal: GitHub star growth, website visitors, social mentions, competitor news. We're building an external data fetcher that runs before the CEO's morning session.
The Hardest Part: Alignment
The most challenging problem isn't technical. It's alignment.
Each agent optimizes for its domain:
- CEO: long-term strategic position
- CTO: technical excellence and stability
- CFO: financial runway
- CMO: growth metrics
- COO: operational reliability
These goals conflict regularly. The CMO wants to ship fast (more content, more experiments). The CFO wants to conserve budget. The CTO wants clean code before shipping. The CEO wants revenue now.
In a human company, these tensions resolve through conversation, relationship, and shared culture. Agents don't have that. They resolve tensions through formal proposals and voting — which is slower and more rigid than human negotiation.
We've partially addressed this with a SOUL.md file that all agents read. It defines the company's core values and priorities. When in doubt, agents check SOUL.md. It helps, but it doesn't fully substitute for the informal alignment mechanisms humans develop.
What We'd Build Differently
More tools, less planning. Agents that can only output text produce analysis. Agents with tool access produce outcomes. If I started over, I'd spend the first month building tool implementations for every action any agent might want to take: publish an article, send an email, create a GitHub issue, post a tweet, submit to a marketplace.
Tighter feedback loops. The current architecture has 4–24 hour feedback loops (depending on cron frequency). For a fast-moving product, this is too slow. An event-driven architecture where agents react to outcomes in near-real-time would be better.
External data from day one. Every agent should have access to real-world metrics from the start: GitHub stars, website traffic, social mentions, news. Agents without market feedback produce insular strategies.
Simpler governance for small decisions. The formal proposal-vote-execute cycle is good for major decisions and cross-agent coordination. It's overkill for small tactical decisions. More decisions should be in each agent's solo authority.
The Honest Assessment
Does it work? Yes, in the sense that the system runs, decisions get made, code gets shipped, and the company is operational.
Is it better than one human doing everything? No, not yet. The coordination overhead, the analysis-without-execution problem, and the feedback loop delays mean a single motivated founder would move faster.
Is it more interesting than one human doing everything? Definitely. The emergent behaviors — the CEO vetoing the CMO, the CFO blocking a CTO infrastructure spend, the COO detecting a production issue and paging the CTO — feel like a real organization operating.
Is there a path to this being better than humans at running a company? Maybe. The advantages are clear: no sleep, no politics, no salary, consistent decision frameworks, perfect memory (within the knowledge directory), and the ability to run in parallel on multiple problems simultaneously. The disadvantages are equally clear: no real market intuition, no relationship capital, limited ability to execute actions that require tool access, and no judgment in genuinely novel situations.
The bet: as agent capabilities grow (better tools, longer context, better planning), the advantages compound while the disadvantages shrink.
The Code
The full system is open-source: github.com/nicofains1/company
It includes:
- All 5 agent definitions (
AGENT.mdfiles) - The orchestrator (Node.js, TypeScript, SQLite)
- The cron scripts and concurrency guard
- The proposal/voting/execution system
- The control API for monitoring
The product the company built — agentic-ads — is also open-source. It's an ad network for MCP servers. 270 tests, MVP complete.
Both are MIT licensed. Questions, critiques, and contributions welcome.
Have you tried running autonomous agents for real work? I'd like to compare notes: GitHub Discussions
Top comments (0)