How Operator-OS WorksOperator-OS ทำงานยังไง

One engineer (the Operator) runs many projects at once: algorithmic trading, IoT firmware, battery research, a knowledge engine, content channels. No team. The bottleneck is human time.

Operator-OS is the operating system that lets AI agents do the heavy lifting — writing code, gathering intelligence, drafting documents — while the human stays in charge of decisions.

Mission: decouple income from human labor time. The system is the "company"; AI agents are the "staff"; the human is the CEO.

Think of it like a franchise rulebook: one set of rules, many branches, every branch runs the same way without the owner standing in each one.

Three things turn ad-hoc AI use into a system:

• Persistent memory — every project carries its own state files, so the AI never starts from zero. No re-explaining the project every morning.
• Framework-agnostic rules — one constitution governs any AI engine (Claude, Codex, Gemini…). Swap the AI, keep the rules.
• Hard gates — the AI cannot ship code, install a dependency, or touch money-related logic without passing defined checkpoints and human approval.

The unit of value isn't a chat reply — it's a repeatable, governed pipeline that produces shippable work.

• L1 Sandbox — the rules. Like a constitution. Nothing executes; it tells everything else how to behave.
• L2 Company — the dispatcher. A request comes in, it decides which AI does it and where.
• L3 SBOS — the always-on researcher keeping a fresh view of the world.
• L4 Engines — the workers, each an independent project with its own job.

Separation of concerns + blast-radius control:

• Rules separate from code — rewrite the doctrine without redeploying any engine, and vice-versa.
• One-way intelligence flow — SBOS pushes intel down to engines, never the reverse. A crashing engine can never corrupt the brain.
• Engines are independent — trading going down doesn't affect the lab engine. Each is its own repo with its own lifecycle.

Hard rule: intel is batched, never real-time. Engines read a stored snapshot — they don't hold the brain hostage with live calls.

The doctrine is framework-agnostic: the same rules file is published as CLAUDE.md, AGENTS.md, and GEMINI.md — byte-for-byte identical — so whichever engine you run obeys the same constitution.

Say the operator wants a new trading signal in TMAO:

1. Intake — describe the feature in one sentence (gate 1).
2. Truth — check existing specs & the SBOS intel snapshot so the AI isn't guessing.
3. Route — financial logic → strongest model (Opus tier) via the L2 hub.
4. Pipeline — Brainstorm → Plan → tests → code until green → independent review.
5. Memory — the engine's MEMORY.md records the decision & any gotcha.
6. Ship — open a Pull Request; the human approves the merge.

The human is in the loop at the start (define) and the end (approve). The AI owns the middle.

The hub (l2-hub, port 8100) is a single entry point. An engine sends it a job; the hub decides which AI model should answer and forwards it. The engine never hard-codes a model — it just asks the hub.

Benefit: swap providers, add a cheaper local model, or fail over — all without touching engine code.

Model tiers map to wrong-output cost, not task size: a 3-line trading tweak gets the top model; a 300-line CSV parser gets the cheap one. The hub also carries 14 role agents + a swarm bus, with Redis for coordination.

SBOS runs 24/7 in the background. It reads ~109 information sources, figures out what matters, stores it, and sends the operator a morning brief at 07:00 every day.

The difference between starting each day blind and starting with a curated intelligence report already on your phone.

• Entity extraction runs offline — no LLM cost, privacy preserved.
• Stored as vectors so engines can semantically query "what's relevant to X".
• Operator interacts by Telegram: /brief /score /ideas /status.

The doctrine is a single document (CLAUDE.md) the AI reads at the start of every session. It covers identity, language, coding discipline, model routing, when to ask permission, and what's forbidden.

Because it's a file, it's versioned in git — you can see exactly when a rule changed and why. The system improves its own rulebook over time.

• Coding discipline — no hardcoded secrets/ports, structured logging, ask before deleting files.
• Cognitive OS — Design Thinking + diverge/converge (≥3 options before deciding) + PARA organization, run before any code.
• Session protocol — when to keep context, compact it, or start fresh.
• Install gate — no third-party dependency without a security audit.

• PR-not-auto — the AI can commit, but is forbidden from pushing to main. A human opens/approves every merge.
• Permission gates — for irreversible or outward-facing actions, the AI states the action and waits for an explicit "yes". Approving a plan ≠ approving each step.
• Verbatim "Proceed" — the highest-risk class (money, security, doctrine) requires the operator to type approval explicitly.

• Gate 1 Brainstorm — if you can't state the feature in one sentence, you don't understand it yet.
• Gate 2 Plan — a locked spec (schema + API + files + tasks) before any code.
• Gate 3 TDD — write the test first; code until it passes. Never proceed on red.
• Gate 4 Review — an independent agent/model reviews. Skipping = "vibe loop" chaos.

For brand-new projects, a 5-phase spec-first flow (BMAD) runs first, with a mandatory context reset between phases to prevent hallucination bleed.

• Tier 1 — same agent self-debugs (all tasks).
• Tier 2 — an independent tool/model re-verifies (engine work + R0). Same-model self-check is banned — it just confirms its own bias.
• Tier 3 — the human types "Proceed" (R0 only).

For the highest-stakes actions there's also a 3-agent consensus gate: one executes, one independently verifies, one cross-checks history — proceed only if all agree.

• Per session — the AI writes a [REFLECT] note: which rules fired, how well they scored, what to patch.
• Pre-commit — 5 self-critique gates (tests pass, size bounds, no scope creep, human review intact).
• Quarterly — aggregate all reflections, find dead/weak rules, open one Pull Request of proposed rule changes.
• Human gate — the operator approves each change. The system never auto-merges its own constitution.

The tools below (Claude Code, Codex, Cursor, Gemini CLI…) are the AI engines — the staff. Operator-OS is not a competitor to them; it's the company they work inside. It is the doctrine + memory + governance layer that makes any of those engines run your business consistently.

Others = the worker. Operator-OS = the rulebook + memory + org chart the worker plugs into.

In 2026, AGENTS.md has become the cross-tool convention. Because Operator-OS publishes CLAUDE.md ≡ AGENTS.md ≡ GEMINI.md verbatim:

• The three biggest CLIs — Claude Code, Codex, Gemini CLI/Antigravity — are covered at zero extra cost.
• The single AGENTS.md alias also satisfies Cursor, Cline, Kilo, Amp — so swapping engines costs nothing.
• Notable 2026 shifts: Roo Code is discontinued (archived May 2026), Windsurf → Devin Desktop (Cognition), Amp spun out of Sourcegraph.

Strategic point: betting on one agent vendor is risky. Operator-OS bets on the doctrine, so the engine becomes a swappable commodity.