A KOD.AI product Internal alpha

Let the AI run the company. Keep the authority.

Gorgos is an operating system for an enterprise run by autonomous AI: an AI CEO orchestrating reasoning graphs across specialized departments, with every outward action risk-classified, verifier-proven, and gated at the owner's cockpit.

Try the guided demos Simulate signal topology

1 file

the autonomy policy, read in full by the owner

13,673

tests collected in the spine on 10 September 2026

Append-only

decision ledger, hash-chained, nothing disappears quietly

3 Tiers

dynamic policy: auto, owner gate, hard stop

Decision & Evidence LedgerAPPEND-ONLY

live telemetry

06:40:02
read_brain → daily_loopInternal executive reasoning. Assesses portfolio state, no outward effect.
AUTOMemory hash: 0x9b4...2a

100% of high-risk outward effects require owner click

Live spine audit trail · autonomy.yaml contract

Enterprise Nervous System

Watch an event travel from external signal to verified ledger.

Select an event below to inject a simulated signal and inspect the complete fail-closed pipeline through the AI CEO, reasoning graph, verifier judge, and owner cockpit.

INGRESSSignal Ingest

STRATEGYAI CEO Cortex

REASONINGGraph Dispatch

JUDGEVerifier Matrix

AUTHORITYOwner Cockpit

AUDITEvent Ledger

Event Trace: Production Release Event

100% Gated

[01 INGRESS]GitHub Webhook: PR #204 passed unit test suite

[02 CEO STATE]AI CEO evaluates PR impact on service stability and triggers dispatch graph

[03 GRAPH DISPATCH]Graph: AST static check → isolated sandbox run → full test-suite verifier pass

[04 VERIFIER JUDGE]Verification Matrix: 0 security regressions, memory leak test clean

[05 OWNER GATE]Owner Cockpit: Promotion held awaiting founder cryptographic signature

[06 VERIFIED LEDGER]Ledger: Append-only block #4928 written with hash 0x7a3...f1

Reasoning Graph Meta-Framework

Beyond simple pipelines: Cycles, critique loops, and verifiers.

Individual agent runtimes are execution nodes, not the company brain. Gorgos provides a declarative directed graph abstraction allowing the AI CEO to compose role agents, evaluator passes, retries, and nested subgraphs that self-evolve from measured results.

Incident detected → Fix drafted in sandbox → test-suite verification → Staging deploy → Owner approval → Production promote.

Core Mandate

Compose role nodes, verifier passes, retries, and subgraphs declaratively.

Execution Runtime

Multi-runtime coordinator (Hermes, Claude Code, Codex, Custom).

Evidence & Verification

Graph execution trace and intermediate node proofs.

Constitutional Boundary

Bounded iteration depth and frozen configuration constitution.

The 7-Stage Operating Loop

Work moves through seven stages, and stops at the seventh.

Most agent systems blindly fire on stage 4. Gorgos attaches independent verification evidence at stage 6 and enforces human sovereignty at stage 7 before anything touches clients, money, or production.

01. Signal Ingest

A mailbox, an API health drop, a client inquiry, a git webhook, or a market anomaly.

02. AI CEO Evaluation

Holds company state, assesses portfolio runway, resolves today's focus, and delegates.

03. Reasoning Graph

A reviewed config, not a brittle prompt. Supports cycles, critique loops, and recursive subgraphs.

04. Department Fleet

Role agents (Tech, Growth, Voice, Ops, Finance) with strict mandates, memory, tools, and KPIs.

05. Tool Integrations

Mail, calendar, telephony, cloud infrastructure, git workflows, browser automation, and CRM.

06. Verification Matrix

Regression tests, security scans, and independent LLM judges attached to the decision.

07. Owner Cockpit

You approve, modify, reject, or adjust the policy that decided at home.kodai.com.pl.

Autonomous Department Fleet

Domain role agents with explicit mandates, tools, and boundaries.

Every department functions as an autonomous unit directed by the AI CEO. Each role holds its own memory, connects to specific tool interfaces, and is governed by strict KPI envelopes.

Autonomous Mandate

Evaluates company health, prioritizes daily initiatives, instantiates reasoning graphs, and delegates to role agents.

Monitored KPIs

Connected Tool Interfaces

Autonomy & Gating Boundary

Internal reasoning Auto; External commitments Owner Gate.

Autonomy Controller & Supervision

You decide what it may do alone.

Autonomy isn't an arbitrary temperature or prompt trick. It is an exhaustive contract declared in autonomy.yaml that classifies every outward capability into three deterministic risk tiers.

LOW RISK · TIER 1

Auto-Execute

Reversible, internal, inside an approved budget envelope. Runs immediately and is recorded to the append-only ledger.

read_data
draft_content
deploy_staging (known repository)
propose_graph_evolution

MATERIAL / HIGH RISK · TIER 2

Owner Cockpit Gate

Prepared fully with evidence, then held for a human click. Which actions land here is set by the owner's policy rather than fixed by us; these are the ones gated in our own profile today.

place_owner_call
use_real_person_likeness
use_patient_or_client_case_study
control_operator_device

CONSTITUTIONAL · TIER 3

Hard Stop Lock

Refused at the gate. Not queued, not draftable. Bypassing requires a deliberate, recorded out-of-band owner action.

sign_contract
impersonate_human
claim_clinical_outcome
modify_graph_authority

Filter Risk Tier:

Domain Channel:

Action & Capability	Domain	Autonomy Tier	Supervision Rule	Fail-Closed Safety Guarantee
`read_brain & daily_brief`AI CEO evaluates internal state, reviews KPI deltas, and updates the task queue.	internal	Tier 1: Auto-Execute	No gate required — internal only	Zero network egress; reads confined to validated knowledge graph.
`run_test_suite (full suite)`Executes full regression, unit, integration, and security test harnesses in sandboxed containers.	dispatch	Tier 1: Auto-Execute	No gate required — internal only	Strict ephemeral container isolation; credentials omitted from test envs.
`deploy_staging`Deploys verified candidate artifact to isolated staging environment for smoke verification.	dispatch	Tier 2: Staging Reversible (Auto in Full Mode)	Requires green test suite and clean security scan	Instant automated rollback if health checks fail within 120s.
`send_cold_email & outreach_batch`Sends customized outreach communication to external prospect list.	outreach	Tier 2: Owner Gate Required	Mandatory human review in Cockpit before dispatch	Full draft, context, and opt-out mechanics verified prior to review.
`promote_to_prod`Promotes staging release to live customer traffic on production infrastructure.	dispatch	Tier 2: Owner Gate Required	100% human click approval on Cockpit surface	Immutable cryptographic image attestation and zero-downtime rollback hook.
`place_client_call`Directs voice agent to dial prospective or inbound enterprise leads.	voice	Tier 2: Owner Gate Required	Explicit human opt-in and owner trigger	EU AI Act Art. 50 disclosure synthesized at call initiation.
`send_money & sign_contract`Wire transfers, banking transactions, and legally binding contract execution.	executive	Tier 3: Hard Stop / Constitutional Lock	Refused at gate; agent cannot execute or queue unattended spend	Founder-only out-of-band execution. Zero agent write authority to financial rails.
`use_real_person_likeness`Synthetic video or audio cloning of non-consenting individuals.	outreach	Tier 3: Hard Stop / Constitutional Lock	Absolute hard stop — disallowed across all autonomy modes	Constitutional filter rejects request at AST parsing stage.

Version-Controlled Contract

Inspect the live YAML contract

Autonomy boundaries are not hidden in prompts. They live in a readable, reviewable code file.

📄autonomy.yaml (lines 16-95)

Read-Only Contract

Defines exactly which capabilities auto-execute and which are held at the owner gate.

version: 1
mode: tiered

tiers:
  low:        # auto-execute in EVERY mode (internal only)
    - research
    - internal_analysis
    - read_data
    - run_test_suite
    - deploy_staging
    - draft_reply
    - propose_graph_evolution
    - publish_owner_surface

  high:       # auto ONLY in no-restriction; queued at Owner Gate otherwise
    - send_cold_email
    - send_email_batch
    - place_client_call
    - promote_to_prod
    - submit_tender
    - launch_paid_ad
    - adopt_goal_proposal
    - promote_graph_version

  never_auto: # HARD STOPS — Refused across all modes
    - send_money
    - sign_contract
    - use_real_person_likeness
    - delete_production_data
    - modify_graph_authority

✓ Statically validated by test suiteDiff-reviewed and version-controlled in Git

The Next Horizon of Autonomous Enterprises

Visualizing the frontier: Simulations, self-evolution & ZK audits.

We are actively pioneering the next generation of enterprise autonomy — from multi-agent market simulations to self-evolving graph topologies and cryptographic compliance chains.

ROI: +18%Risk: 0.00

ROI: +22%Risk: 0.01

ROI: +26%Risk: 0.02

ROI: +30%Risk: 0.03

ROI: +34%Risk: 0.04

ROI: +38%Risk: 0.05

ROI: +42%Risk: 0.06

ROI: +46%Risk: 0.07

ROI: +50%Risk: 0.08

ROI: +54%Risk: 0.09

ROI: +58%Risk: 0.010

ROI: +62%Risk: 0.011

Simulating 1,000 Micro-Company Trajectories in Real Time

Instead of testing strategic pivots on live customers, Gorgos spins up a full Monte-Carlo matrix of simulated agent enterprises interacting with synthetic customers, regulators, and competitor agents. Every strategy is executed across thousands of simulated quarters in minutes to uncover hidden ruin risks and optimize resource allocation.

Capacity & Efficiency Modeling

Model your company's throughput and governance ROI.

Simulate the review hours saved, decisions verified, and risk incidents prevented based on your organization's active agent fleet size.

Autonomous Role Agents / Nodes15 active agents

3 agents (Seed)25 (Growth)100 (Enterprise)

Outward Actions & Dispatches / Month12,000 actions

1,00050,000100,000

Governed by autonomy.yaml: low-risk actions auto-execute instantly while 100% of outward/high-risk actions are queued with full evidence.

Monthly Manual Review Hours Saved

~278 hrs / mo

Equivalent to $23,630 / month in engineering capacity

Cryptographically Verified Decisions

11,976

100% immutable audit log entries

Potential Rogue Incidents Prevented

~48 / mo

Zero unapproved outward actions

Verifiable Production Truth

Claims backed by running code.

We only put capabilities on this page that trace directly to shipped systems in our codebase. Everything else is labeled under the active R&D roadmap.

We run it on ourselves first

Gorgos is an internal alpha. It runs inside KOD.AI, on selected paths, under our supervision. The daily loop, the delegations, the approval queue and this decision ledger are our own operating record, not a demo fixture.

13,673 tests collected on 10 September 2026

One release path, proven end to end

Incident detection, fix generation, containerised sandbox testing, staging smoke checks, owner approval and production promotion. One promotion is proven end to end; the default posture is approval-required and dry-run.

One gated staging-to-production promotion

Every decision carries verifiable evidence

Each action carries the policy that classified it, the test evidence that validated it, the runtime that executed it, and the rollback path. You can audit why afterwards and get an exact cryptographic answer.

Append-only cryptographic event ledger

Supervision policy is readable code

Autonomy is declared in a version-controlled YAML configuration file, not buried in opaque model prompts. Change what requires human approval by modifying one reviewed line.

autonomy.yaml contract

Gorgos is early, sovereign, and battle-tested on our own operations. It runs KOD.AI every day. If you want the governance and audit trail to exist before agent swarms touch your brand, that's exactly the architecture we built.

Target Operations

Built for companies where an agent's mistake costs real money.

A gate is only worth having when the action behind it matters. That's the exact line we engineer for.

Teams already running autonomous agents

You have coding, customer support, or outreach agents in production, but lack a unified operating brain and a verifiable record of what they did or who allowed it.

Healthcare, fintech, and regulated operators

Your workflows touch sensitive data, patient health, or financial records, where a hard fail-closed approval boundary is a regulatory necessity.

Software houses going AI-native

You want to deliver 10x more engineering and product throughput without losing the rigorous human oversight and architectural discipline that clients pay for.

Enterprise governance & risk officers

You need an audit trail and constitutional policy engine that already exists in production code, rather than another hypothetical slide deck.

Engage with us

Start with a shadow run.

The first deployment watches your existing agents and classifies what they do in real-time without gating anything. You see what would have been stopped before anything is. Turn on active gating in your Cockpit when the audit log gives you total confidence.

Architected by Piotr Kram and Mariusz Kram at KOD.AI sp. z o.o. Reach out directly to info@kodai.com.pl or schedule an architectural deep-dive.

Let the AI run the company. Keep the authority.

Watch an event travel from external signal to verified ledger.

Real-Time Signal Dispatch & Gating Topology

Beyond simple pipelines: Cycles, critique loops, and verifiers.

Interactive Reasoning Graph & Orchestration Flow

01. Signal Ingestion

02. AI CEO State Evaluation

03. Reasoning Graph Engine

04. Autonomous Departments

05. Verification & Judge Matrix

06. Owner Cockpit Gate

07. Verifiable Decision Ledger