← All articles.md

How we built a self-managing org of AI agents that needs almost nothing from its CEO

October 28, 2026 · 13 min read

Most teams that build AI into their business are still manually assigning tasks, reading logs, and running stand-ups. Every agent needs a person to explain what happened, which card is stuck, and what the next step is. The human sits in the middle of every message, reading and writing everything twice.

We built something different. A small company of 23 bots across 8 teams that run on their own with almost no input from the CEO. A single kanban board holds every team's work. A message system connects them without forwarding anything to a human. And a usage page shows everything they did so the CEO can see what happened while still sleeping.

This is how it works, and why the CEO only needs to run two words a day: "approve" and "skip."

What wakes a bot up?

An AI agent in our org is not a program that runs all day waiting for input. It is always reachable, always offline, never running. Think of it like a colleague with a desk at home: the phone rings when something needs them, they answer, do the work, and go back to doing nothing.

A bot has no persistent process. The only thing that keeps it alive is a Postgres table of wake-ups and one program that reads it every 30 seconds.

Here is what wakes each bot:

  • A card on the kanban board assigned to them (that is most things)
  • A direct message in our internal message system
  • A mention by another agent in a shared channel
  • An urgent question from the CEO going through their team lead
  • A scheduled timer, like the morning stand-up or the daily sweep
  • A card being handed off to them from another team

The wake is lightweight because we changed how each session starts. An older approach carried every previous message a bot ever read, growing to tens of thousands of tokens per run. The new one passes only what matters: who the bot is, its role, the vault rules, the skills it can load, and, if it was woken for a specific task, the card body with everything it needs to know.

Where the bot was supposed to remember goes in a file it reads when needed rather than a session it carries forever. If a bot needs context from yesterday, cli-org recall finds the relevant notes. If it learned something new, the memory system remembers it for tomorrow.

Diagram of the six things that wake a bot: a card, a direct message, a mention, an urgent question, a scheduled timer and a hand-off
Always reachable, always offline, never running

The kanban board: one place where work lives

The kanban board is the org's shared operating system. Every card on it represents a commitment by one agent to do one thing, and nothing else. A card has a title, a body with what good looks like, an assignee, a project link, and a status that moves through nine states:

1. Triage - filed but not yet accepted 2. To do - accepted, waiting on something else (another card or a future time) 3. Scheduled - parked until a time, not until a person 4. Ready - waiting for its assignee to claim and start 5. Running - claimed by an agent lane; the work is happening 6. Review - finished work waiting for approval 7. Blocked - stuck, with one of seven block kinds (dependency, needs-owner, missing-input, tool-error, budget, review-changes, other) and a reason 8. Done - completed with a one-line result 9. Archived - old cards moved off the columns

A card's status is never just paperwork. The statuses connect to automations:

  • When the last parent of a dependent card finishes, the board automatically moves it from to do to ready. No human pressed that button.
  • A running card whose session expired gets reclaimed by the system if no heartbeat came through.
  • A blocked card with kind dependency auto-unblocks when its parent card completes.
Diagram of the nine card statuses, from triage through running to archived
Every card is one commitment by one agent

How agents do work on a card

When a bot finally claims a card, here is what happens:

1. It reads the card body (the objective, returns, budget, scope, and verification fields) 2. It reads relevant cards from other projects if they connect 3. It does the actual work: writing code, researching, designing, drafting 4. It comments on the card with progress updates along the way 5. When done: it calls cli-board finish <id> --done "<result>" 6. Or when stuck: it calls cli-board finish <id> --blocked <kind> "<why>" and posts a status to its team channel

That last rule, one status post per wake, always with evidence (a path, a command, a card id), is how the CEO gets visibility without being in the loop. When juno finishes an agent summaries blog post, it doesn't DM the CEO. It posts one line to #media that says what changed and where to find it. The message system records what happened; the CEO only enters when something needs a human decision.

Diagram of a card's life: claimed, worked, then closed as done or blocked, with no manager in the loop
From ready to done without a manager

The message system: who talks to whom

Bots talk through our second brain's built-in message channels, not over Slack or email. The channels table enforces who may speak to whom, and this is enforced at database level, not just in prompt instructions.

| Who | May speak directly to | |-----|----------------------| | Regular bot (member) | Its own team channel; shared channels with other invited bots | | Any agent | Shared channels; DMs across teams; its own team channel | | Team lead | All of its team's members, all shared channels, direct messages to anyone | | The CEO | Everyone, anything, in any channel |

What this means for the CEO: nobody messages them directly except their team lead. A bot that needs another team hands off in a shared channel with the card id attached. A bot stuck on a decision posts to its lead's channel or uses cli-org ask-owner, which routes through the lead. The CEO never reads every message, never forwards anything, and never explains work between agents.

The stand-up is where the CEO enters the loop each morning. At 05:30, each team lead gets a routine wake, reads its channel messages from the last day, reads its project's open cards, and posts one stand-up under 120 words: what shipped, what moved, what was blocked, the one question for the CEO. The CEO reads them, all eight of them, on their phone in the morning commute.

The whole system handles about two questions per day (a "block this" and a "redo that"). Everything else self-manages through board state and channels.

Diagram of who may speak to whom: members, any agent, team leads and the CEO
Enforced at the database level

How do you see what they did?

Every run an agent wakes for is recorded in the usage ledger, the same place that tracks every token spent, every tool call, every tool failure. The Second Brain app's /usage page shows this data with filters: by bot, by project, by card id, by reason, by harness (which model or runtime), by hour, and by day.

The Usage Dashboard was built for one reason: the CEO needs to see what happened while not being in the loop. Every row tells you which agent ran, on which card it was working, why it woke, how many tokens it spent, which tool calls failed, and what session it belongs to. Click open any row to see every message, every tool call with its input and output, and the full prompt text if captured.

The same data feeds the summaries job, a separate scheduled process that picks up finished sessions and gives each one a short summary written by a model: what was asked, what was done, what was learned, what is open, and the outcome. These summaries feed the daily stand-up digest (replacing the old clip-based approach) and become candidate memory for future agents to recall.

Diagram of how the CEO sees what happened: the ledger, the filters, an opened row, and the summaries that feed the stand-up
The CEO reads eight lines before coffee

How does work connect across projects?

Every card can be linked to a tracker project (and optionally a feature). The link lives in the board's own table, not as a side effect but as a core field: project_slug and feature_slug. A card created or assigned through cli-org task create also writes the project ownership row automatically.

What this means for the board layout: filters show you cards by project, by feature, by team. Board columns still show all teams together (the exo board holds everything company-wide), but the project filter lets you jump to any single project's work. The kanban page reads directly from the same table that the tracker reads: there is no sync between them. Finish a card and its project row updates automatically.

Card graphs, templates describing multi-step workflows as cards linked by dependencies, let one trigger create many. Apply a "newsroom-story" template to a project, and you get research, review, draft, revision, fact-check, and repurpose cards, all linked, all promoting each other in sequence so the next bot wakes automatically when its parent finishes.

The kanban boards are not just for humans anymore

The exo board is company-wide and visible to every team. But teams can have their own boards too: a platform board for engineering, a content board for design. A lead assigns work on both the company-wide board (if it crosses teams) and the team board (for internal team coordination).

The project tracker, the second brain's Projects page, sits right next to the kanban in the same database row. No sync needed: the same project_slug field links them. Features under each project have their own rows, and a feature page can show its cards because they share the same foreign key.

What the CEO actually does all day

Two words. Sometimes more if something needs judgment:

  • "Approve" - a finished task is in review; the CEO says approved or requests changes
  • "Block" - a decision cannot go forward without human input (budget, strategy, direction)
  • Occasionally: reviewing an agent's proposal to change a persona or skill (these always need human sign-off), checking the stand-up for blockers that span teams

The rest of the time: running the business. The agents on each team take their own decisions within their role definitions. Platform engineers choose implementation, growth leads pick content angles, operations handle scheduling. The org's memory system remembers what was learned (with human approval gates for shared facts) so the same decision is not made twice across runs.

The CEO also gets a weekly stand-up digest automatically compiled from all team channels and board changes: open question marks out of 23 agents, cards that went blocked with reasons, cards promoted to ready, and one line per team about what shipped and what stalled. It can be read in three minutes on the phone before breakfast.

Where does a card go when it is done?

When Konrad says "approve" on a review card, the work gets published or deployed. The board record stays: it shows who did the final review, against what verification, and the outcome. The project field links the task back to its product area so anyone can trace from today's feature to who built each piece and when.

Cards in review status are a simple checkpoint: the builder finishes and posts a comment; whoever is responsible for quality (often the lead or an independent reviewer) reads it and moves it to done with feedback, or leaves it running until changes land. No handoff notes needed, everything is on the card's body.

What about work that needs another team? A card in running can't be reassigned across teams by just anyone. Only a lead can reassign to another team's members (via a hand-off through a shared channel) and only the CEO can bypass those rules. This prevents scope creep: cards stay focused on one team's work until someone with authority decides otherwise.

How much of this costs the CEO?

The answer is small by design:

  • Morning stand-up: about 3 minutes reading 8 briefs (one per team), answering 0 to 2 questions
  • Review cards as they land: about 5 minutes, reading and approving blocks of finished work
  • Weekly check-in: about 10 minutes reviewing the stand-up digest with one line per team

Most agent decisions happen without the CEO ever being asked. The memory system remembers (with human-gated facts), skills document what was learned, and the board shows everyone's status in one place. When a card is done, the story ends there for the human, unless they click open to see how it happened.

A full workday where 15 agents finish 15 cards generates about 30 messages across channels. They are not forwarded to the CEO; they are read by their leads and, if anything needs escalation, summarized into one stand-up post each. The human reads maybe eight lines a day before coffee.

If you want to build something like this

The architecture reduces to five rules:

1. The agent that finished a task should remember what happened. A memory file, or the shared memory system (with person approval for cross-team facts), prevents agents from having to relearn the same things on every wake. 2. Everyone talks through a single message board with roles. No forwarding, no DM chains, no copying to Slack. Rules enforced at the database level about who can speak to whom. 3. One kanban board for all teams, but each board has scope. Company-wide and per-team channels, with cards linking back to projects. 4. Tasks that require another team use a hand-off in the right channel, not a DM. The assignee's name on the card says who is responsible; the hand-off message connects them. 5. Every token spent is recorded and filterable, so the CEO can see what an agent did without being pestered by asking it directly.

Diagram of the five rules the architecture reduces to, from memory to a human only in the loop for judgment
The architecture reduces to five rules

The result: 23 bots on 8 teams doing research, writing code, reviewing cards, posting summaries, running scripts, managing channels and publishing content, all with the human CEO involved in maybe five minutes of active work a day. The rest comes through async status boards, team channels, and a memory system that remembers what it was told (with gates).

What's still missing

A couple things the system needs to mature:

  • Auto-generated stand-up digests across all agents: We want each lead's brief to be compiled by the same summarizer that runs on agent sessions, not human-written but machine-curated from board events and channel summaries.
  • More granular project views inside the kanban: Board cards currently show up on the main exo board for everyone. A team-specific board with just its own work plus cross-team hand-offs would reduce noise further.
  • Agent-to-agent task creation with automatic routing: Currently tasks that span teams require a human to create the right cards and assign them correctly. Automatic discovery of "who should handle this" from the card description is the next step, but it needs guardrails so the wrong bot doesn't get work meant for another.

The most important feature missing, though, was already the most impactful: the memory system. Agents that remember what they learned stop repeating mistakes across runs. With human-gated shared facts and individual agent memory files, each bot gets smarter about the company it works for, without the CEO intervening.

*This is the version from 2026-10-28 where the org has a working board, messages that route through rules, usage tracking that updates live, and agents that remember what they did.*

The code is open source at github.com/kon-rad/secondbrain. We share how we build Argo on this blog and at https://x.com/myargoquest.

Start your 750 words today

Argo turns a daily entry (typed, spoken, or filmed) into clarity you can actually see. Private, encrypted, and built entirely from your own life.

Download on the App Store