00 — STATEFUL AI

A company of one, with the leverage of a team of agents.

Stateful is a local-first AI work server for a company of one.

You drop a directional idea into Slack. A team of persistent, role-specialized agents picks it up — they scope it, plan it, carry the code through pull request and review, and report back as a single Founder Brief. State lives as plain files in a repo you own: runs, tasks, decisions, and approved memory you can read and grep. Agents propose; you approve with a 👍. Local-first, provider-agnostic, and dogfooded — the work server is built by itself. The honest version of an autonomous company: real work, owned state, a human at every irreversible gate.

  • human-gated
  • $0 by default
  • state you own
  • improves itself
Read the founder's story → See the loop ↓

01 — WHO WE ARE

Your agents live in Slack. Their memory lives in your repo.

Persistent roles, a readable trail, founder-owned state.

Most AI tools feel like rented attention — a chat that's gone the moment you close the tab. Stateful is the opposite. The agents are persistent roles, not sessions: each is a folder of config — identity, channels, permissions, memory scope. Everything they do leaves a trail you can read.

State isn't trapped behind a vendor or buried in a vector database; it's plain files in a git repo — runs/, events/, tasks/, memory/approved/, agents/ — that you own and can inspect.

Models are swappable backends (Claude Code and Codex subscriptions, a local GPU, optional hosted APIs); by default it runs on subscriptions plus local GPU, so there's no metered API spend. The north star isn't growth or metrics. It's taste: build genuinely cool things worth having exist.

02 — HOW IT WORKS

Scope → plan → build → review. You hold the gate.

Not a diagram. The actual loop, in the actual product language.

01 SCOPE

Find the wedge and the non-goals — the smallest product that proves the thesis.

🎯 product_strategist

02 PLAN

Design against the real repo, local-first, inspectable, no dead ends.

🏗️ infra_architect

03 BUILD

Break it into small, testable increments; the coder writes real code on a branch.

🛠️ engineering_lead

04 REVIEW

A local prepass plus a Codex pass read the diff; the Skeptic flags overclaims; the CoS synthesizes.

🔴🧭 skeptic + chief_of_staff

state you own · the repo

runs/            # every pass, as markdown
events/          # one JSON record per pass
tasks/           # proposed → approved → done
decisions/       # the why, written down
memory/approved/ # human-gated, readable by all
agents/
  chief_of_staff/
    agent.yaml
    instructions.md

agents/chief_of_staff/agent.yaml

id: chief_of_staff
display_name: Chief of Staff
emoji: "🧭"
autonomy_level: propose   # it proposes; you decide
memory:
  scope: company
  private_write: true
forbidden_actions:
  - approve company memory
  - spend money
  - merge without the founder

# agent = a folder, not code.
# add a teammate = add a folder.

An idea becomes a development stream that runs four stages and pauses at a milestone to wait for you. What it does today, stated plainly: it can carry a scoped change through plan, PR, and review, and prepare it for a founder-approved merge — or adopt an existing repo and work inside it.

Memory, tasks, and decisions are file-based and human-gated. No auto-commit, no shadow archive. The gate is the feature, not the limitation.

03 — MEET THE TEAM

Meet the team.

Six roles, led by the Chief of Staff. Agents are config, not code — a folder is a team member.

Each agent is a real role with a real spec in the repo — identity, voice, channels, permissions, and the things it is explicitly forbidden to do on its own. Every one operates at the same autonomy level: it proposes, you decide. Adding a teammate is adding a folder; the team grows the same way. There's bench depth too — a Release Engineer that drafts release notes but never cuts a release, a Narrative Designer and Game Designer in the gaming pack, a set of analyst reviewers — but these six are the core of how the company runs.

  • Chief of Staff

    chief_of_staff

    Keeps the company operating and synthesizes the Founder Brief; owns self-improvement

    leads the team
    Keeps Stateful operating with focus, cadence, and clear next actions, so one founder moves with the leverage of a small team. Synthesizes every multi-agent run into a single Founder Brief, and carries a standing mandate to improve the company itself — recording friction quietly and only escalating to a proposal when it recurs or clearly earns it.

  • Product Strategist

    product_strategist

    Finds the wedge — the smallest product that proves the biggest thesis

    Shapes Stateful into a coherent product with a clear wedge, MVP scope, and differentiation. Always asks “what is the smallest product that proves the biggest thesis?” — starting from user pain, not architecture, and making the non-goals explicit.

  • Infra Architect

    infra_architect

    Designs the local-first, provider-agnostic architecture

    Designs a local-first, provider-agnostic architecture that starts simple, stays inspectable, and avoids dead ends. Prefers boring, inspectable systems over clever abstractions, and treats Slack, Linear, GitHub, and Notion as swappable adapters — never the source of truth.

  • Engineering Lead

    engineering_lead

    Breaks strategy into small, testable, buildable increments

    Turns product and architecture direction into small, buildable increments with clear tasks, acceptance criteria, and tests. Biases toward the smallest useful slice and working prototypes over abstract platform work — every task testable, every scope shippable.

  • Skeptic / Red Team

    skeptic_red_team

    Stress-tests assumptions; prevents overbuilding and overclaiming

    Challenges assumptions, identifies failure modes, and prevents Stateful from overbuilding, overclaiming, or mistaking excitement for evidence. Direct but constructive; always asks what evidence would change the founder's mind, and separates “interesting” from “useful.”

  • Memory Curator

    memory_curator

    Decides what becomes durable, permissioned memory — not noise

    Decides which context should become durable, structured, permissioned memory so future agents reason better without turning conversations into a noisy archive. Proposes source-linked candidate memories; never commits them — memory is founder-approved by design.

agents are config, not code — a folder is a team member.

04 — THE WRITING

The story behind the system.

From the founder

“I Built a Company of AI Employees” — the first-person account of building and running an agent-operated company of one, documenting the real build, including the loop where the work server improves itself.

This site is the what. The Substack is the why — the first-person account of building and running a company-of-one operated by AI agents, documenting the real build as it happens, including the dogfooding loop where the work server improves itself. If the page made you curious how this actually feels to run, start there.

Read the founder's story →