Overview

What Nika OS is

Nika OS is the agentic runtime used to automate intellectual work. It is not a chatbot. It is not a bag of scripts. It is a system that:

• Orchestrates swarms of agents (MCP-compatible CLI-agent instances, called “pods”) through a real-time inter-process communication layer.
• Persists knowledge across three memory tiers: working memory, episodic memory, semantic memory.
• Evolves its own strategies through prompt-optimization tournaments (inspired by the GEPA research, 2025) — without ever mutating its kernel.
• Routes requests to the right CLI backend based on cost, latency, expected quality, and sovereignty.
• Drives an online controller that adjusts agent hyperparameters from observed signals.
• Perceives beyond text: predictive embeddings (the JEPA family) encode video and time series, and trained projectors bring them into the same space as textual memory — a text question can retrieve a video moment (multimodal perception).
• Renders its deliverables through versioned design systems: brand charters as code, deterministic routing of rendering engines, visual QA before delivery (AI-native design systems).
• Can serve a sovereign model as one backend among the others: a model continuously fine-tuned on the tenant’s corpus, served on serverless GPU, routed by the same primitives as commercial CLIs — for cases where sovereignty outweighs raw capability.

The “OS” terminology is deliberate: we treat agents as processes, memory as a filesystem, IPC as a system bus, and hooks as POSIX signals.

Why this design

A demanding workload is not chatbot territory. A quality-control station receives thousands of measurements a day, a machine setpoint shifts every batch, an operator changes shift every few hours. A naive assistant that restarts from scratch each session has no chance. The system must:

1. Hold over time — memory beyond a single context window.
2. Separate kernel from harness — engraved invariants, mutable parameters.
3. Learn from stress — antifragility in Taleb’s sense, not just robustness.
4. Trace every action — auditability by default, append-only JSONL trail.

Architecture in one picture

                      ┌─────────────────────┐
        user ───────▶ │       Kernel        │ ◀── lifecycle hooks
                      │   orchestrator      │     (SessionStart,
                      └──────────┬──────────┘      PostToolUse, Stop)
                                 │
                  ┌──────────────┼──────────────┐
                  ▼              ▼              ▼
              ┌───────┐      ┌───────┐      ┌───────┐
              │ Pod A │      │ Pod B │      │ Pod C │   CLI-agent
              └───┬───┘      └───┬───┘      └───┬───┘   instances
                  │              │              │
        ┌─────────┴──────────────┴──────────────┴─────────┐
        │                                                 │
        ▼                                                 ▼
  ┌──────────────┐                              ┌───────────────────┐
  │  Semantic    │                              │   IPC bus         │
  │  memory      │                              │  (Redis Streams + │
  │  (Qdrant)    │                              │   JSONL bus)      │
  └──────────────┘                              └───────────────────┘

Who this site is for

This documentation describes the internals of Nika OS for three audiences:

• AI/data engineers who want to understand how to structure multi-agent systems in production.
• Researchers interested in the practical application of recent techniques (GEPA, prompt evolution, online probabilistic control).
• Users and integrators who want to know what actually runs behind the deliverables they receive.

This documentation describes the mechanism — how the system works — in a timeless way. Current execution state (what is running, what is in progress) lives in the status channels, not in this doc.

Product direction

Nika OS runs in production today as the internal runtime of the BCUB3 Lab. A packaged, installable release is in preparation: a multi-OS install wizard, a self-contained image (CLI agents + memory + bridges), encrypted secrets, and this documentation as the contract of the release. The public name of the release: NikaOS.