OMNISLASH: THE PHILOSOPHY

The framework behind the self-evolving operator.

Define the brain — how your company works, as markdown you own. The engine runs it as real operations: durable, governed, self-correcting. Brain + engine together are the self-evolving operator for your company. Agents do the work. Humans govern the policy gates.

THE PARADIGM

AI runs operations with human help. Not a human working with AI’s help — AI working with a human’s help.

The AI does not assist, and it does not “help”. It runs a continuous execution loop: observe → plan → execute → verify → auto-improve, grounded in system state, integrations and strict quality control.

THE CORE PROBLEM

An LLM is STATELESS by design. It can answer one message well. That is all.

For AI to actually carry a process, a framework (the engine) has to own the infrastructure and give models:

  • STATE (memory, context, task graphs, artifacts)
  • TOOLS (the means to act in the digital and physical world)
  • GOVERNANCE (authorization, gates and reality checks)

THE HUMAN ROLE (MINIMAL AND FORMAL)

A human has exactly two jobs:

  1. Define the Brain (Business Scenarios) Write versioned markdown instructions in natural language. Describe goals, constraints, definitions of done and policies. A scenario is not a prompt — it is an operational playbook.
  2. Govern the Policy Gates (Human-in-the-loop) The human is a control point, not a worker.
  • Approve or reject critical actions.
  • Manage risk, time-boxed grants and budgets.
  • Give final confirmation of results (the reality check).

The human is the governance periphery, not the processor.

FROM THE SYSTEM’S POINT OF VIEW (BRAIN → ENGINE)

GIVEN: a brain (your business scenarios, prompts, tools). GOAL: the engine turns the brain into autonomous operations.

The framework takes over:

  • Decomposing natural language into a structured plan
  • Executing tasks in parallel
  • Quality control (Definition of Done) and self-correction on failure

EXECUTION COMPONENTS

Cascade Planner — the Decomposer Natural language → execution graph. It parses a business scenario, splits it into phases and tasks, assigns capabilities and estimates complexity. Before the run starts it self-corrects: the plan is validated, and an ambiguous request goes through a clarification flow. The output is a deterministic execution graph with dependencies, roles and success criteria. A compiler from intent to operations.

Workflow Engine — the Assembly Line Takes the plan and drives it to the finish. Phases run sequentially, tasks within a phase run in parallel. Context groups chain tasks through a single agent. On failure the error is classified and the engine retries or switches strategy. Every task is checked against its Definition of Done. Run status is derived, never stored, and one durable handler is the sole writer of run and task state — zero drift. A reactor that does not stall.

Agent Runtime — the Executors A multi-model runtime: CLI agents (Claude Code, Codex, OpenCode) and API agents through the AI SDK, including gateways (OpenRouter, Vercel AI Gateway) that reach hundreds of models each. One model ref string picks the mode: 'claude', 'smart', 'openai:gpt-4o'. Fallover chains move to the next provider when one fails. A large built-in tool catalog, adaptive rate limits, real-time streaming. An army that does not care who supplies the weapons.

HITL Gateway — Governance One entry point for every human-in-the-loop interaction. Six kinds (question, grant_request, approval, input_request, oauth_consent, interception), one hitl_interactions table, one event pair. Blocking by design: no timeouts, no fast-approve — the human answers when it suits them, and a rejection always ends in a terminal state. Grants come from several producers: some pass through human approval (manual and cron schedules, workflow rehab, an agent’s runtime escape, pipelines), others bypass HITL (declarations, bootstrap, and the admin — the only producer that can mint a subject-scoped grant); all are deduplicated idempotently. The first responder wins through a DB-level CAS — Telegram, the dashboard and MCP broadcast at the same time, and the side effect fires exactly once. Tool authorization fails fast: a gated tool returns a structured error and the agent escalates through hitl_request_grant — the same way it asks for a capability its role does not hold, which an approval adds to that agent. The circuit breaker. AI works exactly within the bounds a human set.

Memory — Context Solves the core LLM problem: amnesia. Memory is markdown in git, indexed for vector and full-text search, recalled into every turn and curated after it. Context between phases travels as file artifacts in a pull model: an agent reads only what its manifest names. Strict, verifiable, no context leaking between tasks. Long-term memory. The system learns instead of starting from zero.

Scheduler — the Proactive Loop The continuous observe → plan loop starts here. Cron-triggered scenarios, natural-language schedules (“every weekday at 9am” → cron), proactive grant provisioning (grants are issued ahead of time so a scheduled run does not stall on an approval at an inconvenient hour). Heartbeats are periodic prompts to agents without workflow overhead (monitoring, daily summaries, health checks). The alarm clock that keeps the system from falling asleep.

Durable Pipelines — Code-Defined Workflows Tier 3 automation on top of Restate: TypeScript handlers with durable execution — crash recovery, automatic retries, compensation on failure. The agent bridge orchestrates Omnislash agents with durable awaitable results. Pipeline approval steps survive restarts (awakeables). A KV store holds cross-step state. For the cases where an AI plan is overkill and code is exactly what is needed. Rails for processes that must not go off the tracks.

Self-Evolving — Closing the Loop Every graded execution feeds a loop: when an entity keeps failing against the metrics the brain declared, a proposer agent proposes concrete changes to its prompts, scenarios or tools. A candidate is replayed against the incumbent before merge, lands as a PR for review, and is watched after merge. Observe → plan → execute → verify closes into auto-improve: every run makes the next one better. Evolution without manual labour.

Screens from Sixty Seconds Studio, a fictional demo studio, running on the real dashboard.