An organization that runs of its own motion.

How autonomous is it, actually?

Ask this of an agentic system: how many human interventions does it take to ship one change? A system that needs a dozen — a nudge here, a re-prompt there, a manual fix at the end — is supervised automation. Autonomy is that count going down.

We call each of those interventions a touch: an approval, a correction, a command, a review comment — a human advancing or redirecting the system. Touches can be counted, and counting them takes structure: work needs a start and an end. That leads to the rule this whole design stands on:

Bounded that way, a unit of work has an envelope — a start, an end, an author, and a written statement of what was wanted, committed to the repository. Measurement attaches to the envelope: duration, cost, and touches read straight from history. Evaluation attaches to it too: the closing artifact is judged against the opening intent — did the result deliver what was asked?

Counting touches on a production pipeline raises a bigger question: where do the agents' context, priorities, and follow-through come from? The pipeline turns out to be one system of three.

An organization is three systems

Strip any organization to first principles and three systems remain. It knows things — strategy, decisions, lessons, context. It produces things — the pipeline that turns intent into shipped work. And it runs itself — the scheduling, measurement, and communication that keep the other two moving without someone standing over them.

AI can now power all three. Plenty of teams are building each one separately: context systems, agentic coding pipelines, automation stacks. We are wiring them into a single working entity and running a real company on it. Suomotu is that entity.

Here is why the combination matters. Imagine pulling the entire software team out of a company. The company is still standing — and most of what makes it a company is still there. The operations continue: the scheduling, the reporting, the communication, the daily decisions that keep the lights on. And the deepest asset is still in the building: the intelligence its people carry — domain experience, hard-won judgment, the knowledge of why things are the way they are. None of that lives in the production line.

An agentic production pipeline, on its own, automates only the part you just pulled out. Our intent is to give the whole company a working implementation: the domain experience and judgment as a Brain agents actually use, the critical operations as an Operating system that runs them, and the production line as a Factory — three systems, wired together, none of them optional.

Software development is the first production line. The design stays general: swap the Factory's playbook and the same organization runs a different business.

The organization at a glance

This is not a humanless company. The design principle is humans at the right touches, in the right places: human judgment sits where it matters — approving intents, ratifying designs, reviewing what agents flag, steering — and agents carry the day-to-day work. Each human-facing interface binds to a role — product owner, reviewer, release manager, operator. A person may hold one role or many.

The Factory

The Factory is what builds things. Work enters as an approved intent and leaves as a shipped, committed artifact; agent workers carry it between those two points, and humans judge it at the gates. The workers are agents. A worker wakes with an assignment, opens an isolated workspace, runs the chain — spec, plan, build, test — and delivers a pull request to the review gate. Humans appear in exactly two ways: at the gates, and optionally on the floor, in hybrid sessions that pair on an intent and produce the same committed artifacts, measured identically.

A change is a work item flowing through the chain: intent.md → spec.md → plan.md → diff and tests → merged commit, with human approvals at the gates between stages. The chain doubles as the audit trail: who asked for what, what the agents produced, and who approved it.

Workers close out. Each run ends in one of three states — delivered, blocked (a committed closeout stating what's done and what's blocking, so anyone can resume), or abandoned (only by human decision at a gate). A run without a closed state surfaces as an alert, not a mystery.

The practices that govern the line are plays — self-contained, each declaring its prerequisites, what it installs, and its own metric — adopted one play at a time, in dependency order, so the Factory is useful at each step. A Factory's set of plays is its playbook, and Suomotu's is the AI-native software development lifecycle. The Factory also finds work: scheduled scans — security, dependencies, code health — file their findings as new intents, which workers pick up on the next shift.

Governance as code

The organization's behavior is configured — in versioned, reviewed files, rather than in anyone's head — through five instruments in ascending enforcement strength. The constitution sets identity: one page, loaded at the start of each session; when an agent makes the same mistake twice, the correction earns a line. Skills put institutional knowledge to work while the work happens — an agent touching an external endpoint loads the security standard and applies it as it writes, instead of a reviewer discovering the violation weeks later. Hooks are deterministic: checks that allow, ask, or block at the moment of action — the rules that hold whatever an agent's judgment says. Permissions are the boundary: standing, versioned rules that define which tools, commands, and paths an agent can reach at all — a hook judges an action as it happens; permissions decide which actions are available. And evals keep the others honest: because configuration steers each agent, changing it is changing the organization, so real past tasks form a regression suite that gates each configuration change.

The Brain

The Brain is a plain-markdown, git-versioned wiki that agents navigate just-in-time and maintain themselves under written governance — and that humans open directly in any markdown viewer like Obsidian. Plain files, deliberately: inspectable, diffable, portable, and navigable by link-following. A scheduled hygiene pass hunts orphans, broken links, contradictions, and staleness.

The Brain and an agent's memory are two different things, and the design keeps them distinct. The Brain is the organization's shared, durable record — one source of truth that agents and humans alike read. An agent's memory is its private working state: the notes it keeps while working, scoped to its own task and session. The two meet in one flow — what an agent learns that the organization should keep is reconciled into the Brain.

What enters the Brain is reconciled, not accumulated: each candidate is checked against what the Brain already says — added, updated, marked as superseding an older claim, or dropped. Contradictions do not stand; superseded claims stay findable, flagged. Each kept memory carries its source and how it was learned, and claims drawn from outside content wait in quarantine until verified — one wrong "fact," quietly reused, compounds through everything built on it. The organization also forgets on purpose: raw detail ages out on schedule, condensed from transcript to log to lesson, and human corrections are pinned — re-validated whenever a page regenerates rather than silently reverted.

The Operating system, in shifts

The Operating system is built in five layers, installed in order: Context — it understands the business (in Suomotu the Brain carries this layer); Data — it sees the numbers daily; Intelligence — it watches and synthesizes; Automate — recurring tasks are audited and automated one by one; Build — the recovered bandwidth becomes new work: intents dispatched to the Factory, which does the building. Each layer is independently valuable before the next is built, and each new automation must improve an autonomy measure — hours the org runs unattended, or the share of recurring tasks automated. A service that ships but still needs daily human attention counts as zero.

The unit of operation is the shift: a named, scheduled window with a roster of jobs and declared dependencies. Each shift opens with a briefing, runs its roster, and closes with a synthesized brief to the operator — committed, like the other artifacts. Shifts feed each other; humans work the openings and closings, in both directions: the brief comes out; corrections and commands go back as recorded inputs. The starter configuration is a night shift (the org gathers and thinks while nobody watches) and a day shift (it acts) — but the model runs as many shifts as the work needs.

Measurement

Each system is measured, and the numbers live in one warehouse — read from the envelopes the operating rule creates. These are the metrics tracked:

Above the per-system metrics sits the autonomy speedometer from the opening question: touches per shift, recorded with the person and the role they were acting in. It should fall as the org matures.

Conclusion

An organization is three systems: what it knows, what it produces, and what runs it. Suomotu wires the three into one entity — governed as code, human judgment at the right touches — and the design aims at a loop that compounds: each shift adds to what the organization knows and trims the touches the next one needs. The measurements exist to show whether it does.

The frame travels: place your own AI effort in it, and ask for touches per shift to learn how autonomous it actually is. We are building Suomotu to make this way of running a company repeatable — Suomotu is the first installation.

If this is interesting to you and you want to learn more, reach out to me.