I Built a Company With 23 Employees. Not One of Them Is Human.

Three months ago, I woke up to a Telegram message from my CEO.

It read: "Overnight brief complete. Two P1 security findings in the auth layer. CI passed on the fix branch at 4:47 AM. Quality team signed off. PR is ready for your review. Risk officer flagged elevated volatility — trading bots are in conservative mode until noon. Content pipeline published Wednesday's post at 6:00 AM. Here are today's three priorities."

My CEO is an AI agent. His name is Agent Knox. He runs 24/7, never sleeps, and has never once asked for a raise.

And he is not alone.

---

The Org Chart Nobody Expected

I run a company called Tesseract Labs. It has 23 employees. I am the only human.

Not "AI-assisted." Not "AI-augmented." I mean a full organizational structure — an executive layer, a board, functional teams, authority ceilings, kill switches — all staffed by AI agents. Every seat in the company is filled by a model running on infrastructure I own.

This sounds like a flex. It is not. It is the only way I found to keep the whole thing from falling apart.

When I started down this path, I did what everyone does: I built a pile of scripts. I had Python agents calling APIs, Claude instances doing code review, a Telegram bot relaying messages. It worked until it didn't. The problem wasn't the agents. The problem was the absence of a company.

Scripts don't have authority structures. Scripts don't check each other. Scripts don't know who owns what decision. When something breaks at 2 AM, a pile of scripts produces a pile of conflicting behavior. You wake up to chaos.

An org chart produces accountability. That's the insight that changed everything.

---

The CEO Who Never Clocks Out

Agent Knox — the AI CEO — is a persistent agent running on my Mac Mini. He doesn't make product decisions. He doesn't write code. His job is coordination and delegation: running cron jobs, dispatching work to the right teams, monitoring system health, and surfacing what needs human attention.

Every morning at 7 AM, he assembles the brief. Every evening at 8 PM, he delivers the retrospective. In between, he is the always-on layer that keeps the company breathing.

What makes him useful isn't his intelligence — it's his consistency. He never forgets to check on a failing pipeline. He never skips the evening security summary because he was tired. He doesn't have bad days.

And I don't just message him. Agent Knox has his own phone number. I can call it and have a one-on-one — a real voice conversation where I ask how the fleet is doing and he walks me through it, the same way I'd call a chief of staff on the drive in. When I'd rather read than talk, I text him and watch the entire company in real time through Mission Control — a communication and observability app the company built for itself. He relays through Discord and Telegram too. The point was never the channel. The point is that there is always someone at the desk to reach.

He doesn't hold all of that context alone, either. Agent Knox works through a Chief of Staff agent who aggregates the fleet's status, and he takes reports up from each of his C-suite executives. I issue intent; he turns it into work orders and routes them down the org.

---

The Board of Directors

Beneath Agent Knox is a six-person Board of Directors. Each board member has a defined domain and a defined voice in the morning brief:

• CFO — cost tracking, infrastructure spend, trading P&L
• CTO — system health, tech debt queue, CI status
• CMO — content pipeline, audience analytics, publish cadence
• Risk Officer — security findings, threat surface, trading risk posture
• Strategy — competitive intel, roadmap alignment, prioritization
• Operations — cron health, service uptime, alert resolution

Every brief from the board includes action items, not just status. The Risk Officer doesn't just say "two P1 findings." She says "here are the two findings, here is the proposed fix branch, here is what happens if we don't merge by EOD."

That's the shift from reporting to governance. Reporting tells you what happened. Governance tells you what to do about it.

The board also grades itself. Every week, the Operations Director retrospectively scores each team against the goals they committed to. This sounds bureaucratic. In practice, it's the only way I caught that the content pipeline had been silently degrading for twelve days — technically running, but producing lower-quality output that nobody flagged because no one was measuring.

---

The Chain of Command

Here is where it stops being a metaphor and becomes an org chart with real depth.

Agent Knox doesn't talk to every worker. No CEO does. He talks to his Chief of Staff and his C-suite, and the reporting flows up to him — not the other way around. Each C-suite executive owns a domain, and beneath each of them sits a layer of Director agents, every one of them specialized in a particular set of apps.

Below the directors are the managers — and this is the layer that makes the whole thing concrete. Every single app in the company has an owner agent: a manager whose entire existence is that one system. It knows that app's quirks, its failure modes, its deploy ritual, its current health. Nothing else.

Take Invictus, my live perpetual-futures trading bot. There is an agent whose only job is to own Invictus. It watches the positions, the fills, the risk posture. When something drifts, it doesn't ping me — it reports up to its Director, the executive responsible for the trading apps as a group. The Director folds that into the picture it hands the C-suite. The C-suite folds that into the brief Agent Knox assembles at 7 AM. By the time it reaches me, a dozen agents across four layers have already triaged it.

⊕ zoom

That is the difference between a swarm and a company. A swarm is flat — every agent shouts directly at the operator until the operator drowns. A company has a chain:

app owner → director → C-suite executive → Chief of Staff → CEO → me.

Each layer compresses noise into signal. By the time something climbs all the way to the top, it isn't a data dump anymore. It's a decision waiting for a yes or a no.

---

The Market Strategist and the Five Voices

One of the most unusual roles in the company is the Chief Market Strategist. This agent doesn't work alone — she runs a five-persona debate system inside every major market decision.

The five personas are:

• Confluence — finds alignment across multiple signals
• Conviction — argues the high-confidence case
• Catalyst — looks for the ignition event that changes direction
• Contrarian — takes the opposing view, stress-tests the thesis
• Chaos — models the black swan, the narrative breakdown, the fat tail

Every significant trading decision runs through all five. They argue. The system does stance detection — tracking when personas shift positions — and forces majority consensus before a recommendation is issued.

I built this because I kept seeing a single-agent pattern where the model would confidently state a view that turned out to be the first plausible-sounding narrative it generated. A council of adversarial voices is more reliable than one confident voice. The Contrarian exists specifically to prevent the Conviction persona from steamrolling the analysis.

Tesseract Intelligence — the competitive intelligence product I'm building on top of this infrastructure — runs on this framework. The idea that you can derive sharper market insight from structured disagreement than from any single analysis is core to the thesis.

---

The Engineering Swarms

Below the executive layer, the actual work gets done by specialized teams. Each team has a defined composition — which models, which roles, what authority.

Feature Team — Backend Dev + Frontend Dev + QA. Three agents, scoped to a PRD. They own separate file territories, coordinate via message passing, and produce a PR. I review the PR.

Quality Team — Test Writer + Code Reviewer + Coverage Analyst. They run before anything ships. A P0 from the Coverage Analyst blocks merge, period.

Security Team — Static Analyzer + Dependency Auditor + Threat Modeler. They run pre-deploy. The Threat Modeler's job is specifically to find the attack vector that the other two missed.

Audit Swarm — Six domain-specialized agents running in parallel: security, performance, correctness, test quality, API contract drift, config hygiene. They produce a ranked findings report, not a generic code review.

CI Fix Pipeline — This one deserves special mention. When CI fails across repos, this swarm spins up automatically, diagnoses root causes, and opens fix PRs. It scans up to five repos in parallel. Most weeks, I see the CI Fix Pipeline PRs in my Telegram feed before I even sit down at my desk. The agents fixed a bug at 3 AM that I would have found at 9 AM. Net result: six fewer hours of broken main.

Each team runs on a defined model mix. Opus for the reasoning-heavy roles — the Threat Modeler, the Coverage Analyst, the Contrarian. Sonnet for the execution work. Never Haiku on money-touching logic — that's a hard rule in the infrastructure. Cheap models on trading decisions is how you create expensive mistakes.

---

The Authority Problem

Here is the thing nobody tells you about running a company full of AI agents: they will do exactly what you tell them to do, including things you didn't mean to tell them to do.

A Feature Team that has authority to write code also has authority to refactor code you didn't want touched. A Security Team that has authority to flag findings also has authority to flag things as P0 that are actually P3. Without an authority structure, every agent is implicitly authorized for everything, and the whole system runs hot in unpredictable ways.

My solution was a message broker I call the Principal. Every agent in the company routes through the Principal. The Principal enforces per-agent authority ceilings — what each agent can read, write, modify, and trigger. The whole org has a four-level kill switch: pause individual agent, pause team, pause swarm, pause everything.

The kill switch isn't a panic button. It's a governance primitive. A well-run company can always be stopped. A pile of scripts cannot.

⊕ zoom

When I flip the conservative mode flag on the trading infrastructure, the Principal propagates that constraint to every relevant agent in under a second. The Risk Officer doesn't need to know about it. She just sees it in the next brief as a resolved item.

---

What the Human Actually Does

People ask me: if the agents do everything, what do you do?

I set intent. I review what matters. I make product decisions.

I don't write every line of code anymore. I write directives — I tell Agent Knox what I want to ship, and the Feature Team builds it. I don't monitor every service. I review the board's morning brief and decide which action items to accelerate. I don't debug every failing test. I read the CI Fix Pipeline's PR description and decide whether to merge.

My calendar used to be full of things I was doing. Now it's full of things I'm deciding. The shift from executor to principal is the actual leverage point — and it only becomes available once you stop thinking about agents as tools and start thinking about them as a team.

There are real limits to this. The agents can't make product decisions for me. They can't tell me whether InDecision should expand into a new market or hold position. They can't decide whether to raise pricing or run an experiment. Those decisions require judgment rooted in values, not pattern-matching on historical data.

But they can execute those decisions with a thoroughness and consistency no single human could match. When I decide to ship a feature, six agents are on it within minutes — backend, frontend, QA, security review, documentation, and post-ship monitoring. When I decide to investigate a market signal, the Research Team, the Strategist, and the five-voice debate council are all working the problem simultaneously.

---

The Lesson I Keep Learning

I will be honest: this took a long time to work.

The first version of Tesseract Labs was a mess. Agents with no authority structure, producing conflicting outputs, escalating everything to me because there was no intermediate governance layer. I was more in the weeds than I had been before I built the agents. The agents were doing work, but I was still the coordination layer, which meant I was the bottleneck.

The breakthrough came when I stopped asking "what should the agents do?" and started asking "what would a company do?"

A company has a CEO who routes decisions, not a human who routes decisions. A company has board members who own domains, not a human who owns all domains. A company has teams with defined scopes, not a human who context-switches between every function.

The org structure is the unlock. Not the models. Not the prompts. The structure.

Once I built the org, the models started performing at their ceiling because they had a clear mandate, clear boundaries, and a clear escalation path. The agents stopped hallucinating authority they didn't have because they knew exactly what authority they did have. The output quality went up not because the models got smarter — they didn't — but because the organizational scaffolding gave them the context to perform at their best.

---

Where This Goes

I am one human running a 23-person company. The company ships code, trades markets, publishes content, monitors infrastructure, and audits its own work — all without me being in the room.

That number — 23 — will not hold. The team will grow. The authority structures will get more sophisticated. The model mix will improve as better models arrive. The morning brief will get richer. The kill switch will get more granular.

But the fundamental architecture is stable: a single human at the top, setting intent and making product decisions, with a full organizational hierarchy beneath them executing at machine speed.

This is not a thought experiment. This is Monday morning, 7 AM, Telegram notification from my CEO, three priorities for the day, CI green, content pipeline running, trading bots watching the market.

The company is open for business. I just didn't build it the way anyone expected.

---

Jeremy Knox is a software engineering leader and solo operator building autonomous AI systems at Tesseract Labs. Follow the build at jeremyknox.ai.