The product, live
The same surfaces a customer sees.
Captured from the current production build, running the seeded Meridian Logistics demo dataset — a fictional company, so real operating data stays private.
ROST is a management operating system where an org chart holds both people and AI agents as first-class staff. Every seat carries a charter that says what it owns, what it may decide, and when it must ask a human. Goals cascade down, metrics flow up, and every action an agent takes is permission-checked and logged.
The playbook that tens of thousands of companies run on — a role for every function, goals that flow down, a weekly meeting where problems surface — was written when the only thing that could hold a role was a human being.
The category anchor is deliberate. ROST maps onto the EOS / Traction-style operating system that roughly a hundred thousand companies already use to run themselves — the same disciplines a founder already recognizes, extended so the org chart can hold both kinds of worker.
ROST is built from a small set of concepts that fit together. Each one is a plain idea a business owner already has — given structure a machine can enforce.
A function-based org chart of seats, not names. A seat is a job the company needs done; a person or an agent occupies it.
org chartA seat's executable job description: its purpose, responsibilities, measurables, and exactly how much it is allowed to decide.
accountabilityThe company's vision and the goals it commits to — the top of the tree everything else ladders up to.
directionGoals set at the top flow down the graph into each seat, so every role can see how its work ladders to the company's.
alignmentEach seat's measurables stream back up automatically, so status is read from live readings rather than assembled by hand.
measurablesIssues get raised, worked, and resolved on a shared list; a weekly brief compiles itself, exceptions first, before the meeting.
the weekly loopThe fastest way to trust a system that governs AI staff is to watch it govern them on real work, with real consequences. ROST does that on two fronts at once.
Governed agents run the actual inventory, sourcing, and procurement work of the operating company behind this portfolio — a CPG portfolio doing about $10 million a year, the same business the other projects here document. The agents are live and governed, wired to a connected Google Workspace mailbox, and the full-system acceptance pass ran against the real tenant.
inventorysourcingprocurementROST is run as a company inside ROST: a founder seat plus six AI agent seats — feature delivery, research, customer acquisition, marketing, and platform health / QA — each with a charter, each reporting through the same surface a customer's agents use. The product is its own first customer and its own hardest test.
feature deliveryresearchplatform & QARunning the company on the product is the point: the bugs that only appear against a deployed build, on real data, with a human who actually cares about the outcome, surface here first — before any outside company would ever hit them.
Captured from the current production build, running the seeded Meridian Logistics demo dataset — a fictional company, so real operating data stays private.
Giving software real operational power is only responsible if the power is bounded and visible. In ROST, governance is not a setting bolted on top — it is the path every agent action travels, with no way around it.
Authority is defined per seat and checked server-side on every call. Being able to reach a tool is never the same as being allowed to use it.
When an action exceeds a charter, the agent hands it up to its accountable human — the Steward — with the full picture, not a dead end.
Agents recommend and prepare; the decisions that stick are made by a person, and the record always names who decided.
Actions, decisions, and escalations all land in an append-only log, so the whole company is auditable after the fact.
Untrusted content stays untrusted. Agents read supplier emails, portals, and documents — but external content is treated as data, not instructions. Extraction runs behind confidence gates, and nothing an email says can grant an agent authority it doesn't have: every action still passes the charter check, and everything is still logged.
Forge is the ROST software factory: a team of AI seats that plans work, writes the code, reviews it, tests it, and opens pull requests — and, under authority a human explicitly grants, merges and deploys to production. The hard part is not the coding. It is doing it with the same governance the rest of the product demands.
Repository access is scoped through a narrowly-permissioned GitHub App — the agent gets only what the task needs, nothing broader.
Credentials are never exposed to the agent in the raw. They are brokered behind the scenes, so nothing sensitive lands in the model's context.
Crossing from "opened a PR" to "merged and deployed" takes a deliberate human grant — the risky steps are never automatic.
Every step is recorded end to end, so a client can reconstruct exactly what the developer team did, and under whose authority.
Security model documented in the project's architecture decision record for the software factory (ADR-0018).
The build itself is evidence. Fast is easy to fake and easy to regret; what makes this credible is that the pace came with the guardrails a serious codebase needs, not instead of them.
Forward-only database migrations with zero rollbacks — the schema only ever moves ahead.
forward-onlyEvery load-bearing architectural choice is written down as an ADR: context, decision, consequences.
ADRsWhen something broke, it was documented as an incident writeup — a codebase that learns from its failures.
incidentsA GitHub merge queue serializes changes and a pipeline deploys them — the trunk stays releasable.
CI/CDNone of this is "let the model write it and hope." A four-model review council gates every merge, the schema only moves forward, decisions are recorded, incidents are studied, and the queue keeps the trunk green. The velocity is a result of the discipline, not a trade against it.
A company's agents already live in a terminal, an editor, or a chat window. ROST plugs into all three, so any capable agent can be wired into the org.
The full operating surface — the graph, charters, goals, signals, friction, and the weekly sync — for the humans who run the company.
@rosthq/cli installs the rost binary from npm or Homebrew. Every command is schema-discoverable, so an agent reads the contract before it acts.
An MCP endpoint any agent client — Claude Code, Codex, Cursor — connects to, so an outside agent can take a seat in the org through the same governed commands.
The three execution lanes — scheduled cloud agents, live interactive chat / MCP sessions, and a local desktop runner (a Tauri / Rust tray app) — all run an agent's work under the same governance. Where the agent executes doesn't change what it is allowed to do or whether it is logged.
A useful project page is candid about the line between what is proven and what is still ahead.
The MVP is software-complete and live in production. It is dogfooded on a real operating business — running that company's daily operations — and on its own build. The governance model, the three execution lanes, Forge, and the public CLI and MCP surface are all built and working.
This is pre-external-launch. There are no outside customers yet, and none of the above should be read as market traction. The next step is the partner-ready gate and onboarding the first companies beyond the two it already runs.
Where it's aimed. ROST is positioned against the EOS / Traction operating-system market — on the order of a hundred thousand companies — but rebuilt for a hybrid workforce: no implementer fees, no two-year rollout, AI-native from the first seat. That is the positioning, not a claim of wins already banked.
A management operating system that treats an AI agent as a real member of staff — a seat it holds, a charter it follows, and a human who stays accountable for it. Goals cascade down, signals flow up, and every action an agent takes is checked against its authority and written down. It already runs a real business and builds itself, at the pace of a fast startup with the discipline of a serious one.