Platform
Agent operating system
Shared lifecycle kernel, pluggable sub-modules, and the semantics you operate in production — illustrated with mock runtime data until M2 API wiring.
Control room
Operate runs like production — before API wiring
Preview of M2 Control Center — all numbers and rows are illustrative until the API is live. No customer metrics implied.
Active runs
12
illustrative demo
Eval pass rate
96.4%
illustrative demo
Spend / mo
$842
illustrative demo
Avg cost / run
$0.38
illustrative demo
| Task | Agent | Stage | Eval | Cost |
|---|---|---|---|---|
| KHA-142 auth middleware | KHEPRI | REVIEW | 94% | $0.41 |
| Module sync webhook | NADIR | DELEGATE | — | $0.12 |
| Independent QA pass | AEGIS | QA | PASS | $0.09 |
| Human merge approval | HUMAN | HUMAN_APPROVAL | pending | $0.00 |
Maturity model
Autonomy levels map to the same kernel
From assisted requests to governed autopilot — one lifecycle, stricter gates as level increases.
Human drives; agents draft inside scoped tools.
REQUEST · PLAN
Chief of Staff delegates; human supervises the graph.
DELEGATE · IMPLEMENT
Runs complete loops; QA and policy gates enforced.
REVIEW · REMEDIATE · QA
Agents replan within policy; human only at authority gates.
HUMAN_APPROVAL · DONE
Builder
Mount a sub-module on the kernel
Declarative boundary: roster template, skills, data scope, and which kernel gates apply. Orchestration stays shared.
// sub-module manifest (illustrative)
export const module = {
id: "your-module",
chief: "nadir-template",
skills: ["research.pack", "report.emit"],
dataScope: "tenant-isolated",
gates: ["kernel.qa", "kernel.human_approval"],
};Khamseen is an agent operating system: a shared kernel for lifecycle, policy, and audit. Sub-modules plug in on top — any workload you define.
KERNEL STAGE PLAN
Human Authority sits at the root. Agents form an organization — not a chat thread — with explicit roles, scopes and escalation paths.
The control plane coordinates delegation, budgets, permissions and observability across the graph. Every edge is a handoff with a contract: who acts, what they may touch, and what must be verified before the next stage.
The kernel owns scheduling, delegation, and gates. Sub-modules supply rosters, skills, and integrations without rewriting orchestration. Mock runtime data on this page previews those semantics.
Agents in graph
50+
role-scoped, not prompt personas
Approval gates
8
lifecycle stages before DONE
Reviewer separation
required
implementer ≠ verifier
Runtime context
isolated
worktrees · budgets · tools
Four constraints that keep the system honest when agent count scales.
KERNEL STAGE REQUEST
Graph over thread
Work routes through a topology with explicit handoffs. Delegation is structured, not a longer chat log.
Evidence over vibes
QA agents, tests, and security scans produce pass/fail signals. Humans approve outcomes backed by artifacts.
Policy over prompts
Capabilities, scopes, and budgets are enforced at runtime — not renegotiated in every message.
Human at the root
Production deploys, spend overrides, and policy exceptions escalate to Human Authority — by design.
Kernel + sub-modules
Khamseen is the OS layer: fixed lifecycle and gates. Sub-modules plug in workloads — any shape — without forking orchestration.
Delegation is a structured packet: outcome, constraints, budget, and reviewers — not a longer system prompt.
KERNEL STAGE DELEGATE
Human
↓ outcome specified
Chief of Staff
↓ plan + delegate
Agent Graph
→ specialists execute in parallel
You specify outcomes. The system routes work through the topology — not hand-authored prompt chains.
Example delegation
Complete a scoped deliverable under org policy (example run #1842)
Constraints
- · No production deploy
- · Independent QA before close
- · Budget cap enforced
Routing
- → Chief of Staff plans graph
- → Implementer executes
- → Reviewer verifies
- → Human approves outcome
Runs are isolated units of work. Each primitive below is observable in traces and billing.
KERNEL STAGE IMPLEMENT
Isolated execution
Each run gets bounded context, tools, and filesystem scope.
Worktrees
Parallel implementers without cross-contaminating branches.
Tools & MCP
Agents call approved integrations — auditable, rate-limited.
Agent Skills
Packaged playbooks the control plane can assign by role.
Capabilities
Fine-grained allow lists (e.g. git.commit, review.independent).
Context boundaries
Token and memory limits per agent class.
Tasks
Durable units of work with IDs, owners, and lifecycle stage.
Runs
Time-bounded executions with cost, state, and trace export.
Verification agents never share the implementer's context boundary. Pass/fail is evidence-backed.
KERNEL STAGE REVIEW
- · Independent reviewers (separate from implementers)
- · Automated tests and QA agents
- · Security scans and policy gates
- · Evidence-based pass / fail — not self-approval
AEGIS-class agents consume artifacts — diffs, test reports, scan output — and emit a verdict the graph can route on. Sentinel and Pulse cover security and drift without blocking the main delivery path unless policy requires it.
Micro-loops correct a unit of work. The macro-graph decides what runs next when policy or QA fails.
KERNEL STAGE REMEDIATE
A loop makes a unit of work correct. A graph decides which unit executes next. Remediation runs are first-class runs — new cost, new trace, same gates.
- · Issue detected → routed back to implementer with scoped fix list
- · Re-review mandatory; implementer cannot self-clear QA
- · Repeated fail → escalate to Human Authority or chief-of-staff replan
Each sub-module defines its own hierarchy — chiefs, specialists, workers — mounted under the same Human Authority root.
KERNEL STAGE PLAN
Human Authority
→ Chief of Staff
→ Managers
Compose the OS with pluggable modules. Same lifecycle and gates everywhere; each module brings its own skills, data scopes, and chiefs.
KERNEL STAGE DONE
OS kernel (shared)
REQUEST → PLAN → DELEGATE → IMPLEMENT → REVIEW → REMEDIATE → QA → HUMAN_APPROVAL → DONE
Every sub-module inherits this lifecycle and the same Human Authority gates. Modules differ in agents, skills, tools, and data — not in orchestration semantics.
Agent roster
Roles, hierarchy, and handoffs inside the module — mounted on the shared graph.
Skills & tools
Packaged capabilities and MCP integrations allowed for this module only.
Data scope
Stores, APIs, and retention boundaries — isolated from other modules by default.
Policy overlays
Optional extra gates (e.g. compliance checks) before kernel stages advance.
Illustrative slots (yours can be anything)
Module you define
Any vertical or internal function — same kernel, your agents and skills.
Second module
Runs in parallel: separate scope, separate budgets, shared Human Authority root.
Experimental module
Quarantined skills and tools; cannot reach production paths without promotion.
Tenant module
Multi-tenant installs: per-tenant roster and data fence on one control plane.
KERNEL STAGE PLAN
| Axis | Typical chat | Khamseen |
|---|---|---|
| Structure | Linear transcript | Organization graph + roles |
| Verification | Model self-check | Independent reviewer agents |
| Permissions | Implicit in prompt | Capabilities & scopes enforced |
| Cost | Opaque session | Per-run metering & caps |
| Production | Manual discipline | Human Authority gates |
Is Khamseen a chat wrapper?
No. It is an agent operating system: delegation, lifecycle, permissions, and review are first-class — the UI reflects runtime state, not conversation history alone.
Who approves production changes?
Human Authority. Agents propose and implement; gated stages (QA, security, budget) must clear before you authorize deploy or merge.
What is a sub-module?
A pluggable package on the OS: your agent roster, skills, tools, and data scope. The kernel owns lifecycle stages, delegation, audit, and Human Authority — unchanged across modules.
Do I pick from a fixed list of domains?
No. You create sub-modules for whatever workloads you need. Examples on this page are placeholders — the product is the kernel plus composable modules, not a vertical catalog.
Can several modules run at once?
Yes. Each module keeps its own graph slice, budgets, and evidence trails. One orchestration semantics; many isolated workloads under the same root policy.
Slack or WhatsApp instead of a dashboard?
Channels are ingress/egress adapters. You can approve, delegate, or receive alerts in chat — but transitions still flow through the kernel graph, not ad-hoc bot logic.
Why an OS instead of LangGraph, CrewAI, or chat?
Frameworks orchestrate steps inside an app. Khamseen is the organizational layer: fixed lifecycle, Human Authority, sub-modules, integrations, and ops surfaces (metering, eval, audit) meant to run many workloads under one policy root.
KERNEL STAGE QA
Landing · graph · execution narrative
Docs & read-only Control Center (API-backed)
Module SDK · scaffolding · registry
Mount your modules on one OS.
Follow task KHA-142 on the live trace demo, or explore the open core on GitHub.