13 AI Agents Running 14 Companies: Five Non-Negotiable Red Lines

One human, 13 AI agents, running 14 startups — 12 of which already have live products. This isn't a sci-fi premise; it's how developer Jukka Blomberg actually works. Over the past 90 days, his agent fleet has completed 1,235 deliverables, all recorded in an append-only ledger.

Most people's first reaction on hearing this is: how do you make sure nothing goes wrong?

Jukka's answer is surprisingly plain: a very short "absolutely forbidden list," plus a very long "go do it list." The core logic is just six words — narrow gates, wide autonomy.

A system that asks permission for everything eventually gets ignored; a system that asks for nothing eventually drains your bank account.

The Five Gates: Things Agents Are Never Allowed to Decide on Their Own

These five categories of operations form the safety floor of the entire system. No matter how "smart" an agent is or how urgent a task is, it cannot bypass them:

1. Anything involving real money. Payment gateway integration, pricing changes, payouts, refunds, adding paid seats or plans — all require human confirmation.

2. Authentication and keys. Agents may never create, rotate, or submit any credentials. They can write code that reads environment variables, but the values must be filled in by a human.

3. Outbound sending and publishing. Emails, DMs, social media posts — any action that reaches a third party under your name is outside an agent's autonomous authority.

4. Scheduled automation. Creating, disabling, or rescheduling any task that "runs automatically unattended" must go through approval.

5. Destructive or irreversible changes. Deleting data, modifying DNS and domains, production migrations — once these go wrong, there's no way back.

Interestingly, Jukka shares an example in the article that happened in real time: the very article drafted by an agent was allowed to be published on some channels, but not others. That evening, an agent drafted a post for one company's page and tried to publish it. The safety check stopped the click. Jukka's assessment of the outcome — this wasn't a failure, but the system working as intended. The draft became a one-minute action sitting in front of him, waiting for him to press the button.

Industry context on "gates." In the AI agent space, a "gate" is usually referred to as Human-in-the-Loop or Human-on-the-Loop. The difference: the former means an agent waits for human approval at every key action, while the latter means humans only monitor and backstop, letting agents operate autonomously within set boundaries. Jukka's five gates are a classic "human-in-the-loop" design, triggered only for high-risk actions. The accompanying concepts are approval gates and permission boundaries. It's widely accepted in the industry that a mature agent system must be able to answer: which actions are read-only, which are reversible writes, and which are irreversible — each category should have a different approval strategy. Jukka's list is divided by "degree of irreversibility" rather than "technical difficulty," which is precisely why it covers the vast majority of risks.

Gates Aren't Walls — They're Boundaries You Can Loosen One at a Time

Many people interpret "gates" as permanent red lines. Jukka's approach is more flexible: when he wants an operation covered by a gate to run autonomously, he first writes an envelope.

An envelope contains four elements:

• The specific scenario it covers (that one only)
• Hard caps (how much money, how many sends, how many people reached)
• Stop-loss rules (under what conditions it halts immediately)
• How each automated action is tagged in the log

Everything outside the envelope is still drafted by the machine and executed by a human. This design lets autonomy be released drop by drop, rather than opening the floodgates all at once or locking things down permanently.

Where the "envelope" idea comes from. The envelope mechanism isn't original to AI — it borrows from risk budgets in financial risk control and flight envelopes in aviation — pilots can operate freely within the envelope, and crossing the line triggers alerts or even automatic takeover. In agent frameworks, this maps to explicit modeling of Policy as Code and scope of authority. Compared to blunt on/off permissions, the value of an envelope is that it breaks "autonomy" into measurable parameters: dollar caps, frequency caps, reach counts, time windows. This also makes auditing possible — because every automated action can be asked: which envelope does it fall into? If no matching envelope exists, it's an overreach.

Three Habits That Make the Gates Actually Work

Rules alone aren't enough. Jukka also relies on three mechanisms to enforce them:

Every agent has a one-page contract

Before an agent runs, there must be a contract specifying: who's in charge, task scope, operating cadence, which data it can read, which data it absolutely cannot see, where it writes, which gates apply, who the escalation path goes to, and under what conditions it terminates immediately. No contract, no running.

An append-only ledger as an audit trail

Every row follows the same format: date | entry ID | source | project | status | notes, and status has only four values: BUILT, PARTIAL, ESCALATED, KILLED. Once a row is written, it cannot be modified. If an entry mysteriously disappears, that means something went wrong in the handoff process — not "data cleanup."

What "append-only ledger" means technically. Append-only ledgers are a common pattern in distributed systems and financial infrastructure; the most famous implementation is blockchain's underlying data structure, but ordinary enterprise systems also use WAL (Write-Ahead Log) and event sourcing to achieve the same effect. The core guarantee: once a historical record is written, it cannot be silently modified or deleted — any tampering leaves a detectable trace. For agent systems this matters enormously — because agents execute fast and concurrently, and when a hallucination or overreach occurs, whether you can precisely trace back "which step, which input, which decision" afterward determines whether the problem can be fixed. The append-only ledger makes the "chain of responsibility" undeniable and turns "the agent says it did X" into an independently verifiable fact.

"Done" means the check has already run

"Should be fine" doesn't count as a result. A premise disproven and closed with evidence counts as a successful run; escalating to a human also counts as progress. Absolutely no fabricating numbers, dates, or test results.

These three habits look simple, but they're exactly what turns "narrow gates, wide autonomy" from a slogan into a working system.

Not Just a Personal Experiment: A Reusable Organizational Template

Jukka has written this model up as a template organizations can adopt, including principles, a gate matrix, agent contracts, ledger format, the envelope mechanism, metrics, and how to map it to team deployments on Claude, Copilot, or OpenAI. The template is released for free under CC BY 4.0, with a Markdown download.

The task scope and operating cadence of each agent in his fleet are also publicly available on the website. If you're pushing AI adoption in your team and want to exchange notes, just write a paragraph about your AI progress and needs.

What's most worth borrowing from this approach isn't how complex it is, but that it gives an extremely concrete answer to the question of "where humans should retain control." Against the backdrop of rapidly expanding AI agent capabilities, most discussion centers on "what agents can do," while Jukka's practice points to a more critical question: at which nodes must a human press the button.

Narrow gates, wide autonomy — these six words may be the most pragmatic AI agent management philosophy out there right now.

About the CC BY 4.0 license. CC BY 4.0 is an open license published by Creative Commons, formally known as "Attribution 4.0 International." It allows anyone to freely copy, distribute, adapt, and even use the work commercially, with the sole hard requirement that the original author be credited and any modifications noted. This means Jukka's agent governance template can be adopted directly by enterprises, further developed, or even integrated into commercial products without paying licensing fees or signing additional contracts. For teams wanting to build AI governance processes quickly, this license dramatically lowers the adoption barrier — one reason the template has spread rapidly through the community.