Automation Tiers

Omnislash provides three tiers of business workflow automation. Each tier gives progressively more control and engineering precision. A business starts at Tier 1 and escalates specific workflows to higher tiers as needed.

The Problem

Every AI-first automation platform hits the same wall: businesses start with AI automating everything, it works for 80-90% of workflows. But critical, high-value workflows eventually need more predictability than “the agent figured it out.” At that point, the business concludes “we’ve outgrown this platform” and leaves.

Omnislash solves this with an escalation path: don’t leave — escalate that specific workflow to the next tier. The other 90% stay AI-managed.

Tiers

Tier 1: AI End-to-End

Audience: Business users, non-technical staff.

Flow: User describes a task in natural language → Cascade Planner generates a blueprint → Workflow Engine executes with durable agents → Eval evaluates results → Improve loop refines prompts and plans over time (self-evolving.md).

Control model: Trust the agents. They have memory, auto-improve, and eval feedback loops. The user’s job is to describe what they want and refine prompts when results aren’t satisfactory.

When to use: New automations, exploratory workflows, anything where “good enough” is acceptable and iteration speed matters more than precision.

Tier 2: AI + Blueprint Lock

Audience: Power users, business analysts, technical staff.

Flow: Start from Tier 1 — let AI generate the plan. The planner writes it as <name>.blueprint.yml beside the scenario (contract.md § 3). Hand-edit it (reorder tasks, fix context groups, adjust definitions of done), add a top-level locked: true, and the planner stops regenerating it — every run executes your edited plan.

Control model: AI generates the starting point, human locks the structure. Execution is still agent-based (durable, with eval), but the plan is deterministic — no re-planning on each run.

When to use: Workflows that run repeatedly and need consistent structure. The blueprint works but you want to freeze it, remove variance, and iterate on specific steps without AI re-planning each time.

Tier 3: Code-Defined Workflows

Audience: Software engineers.

Flow: Developer writes a typed, deterministic pipeline in TypeScript using Restate (<scenarioId>.pipeline.ts inside the scenario’s feature — pipelines.md). Each step is explicit: API calls, data transforms, branching, parallel execution, durable agent calls, HITL gates. The full Omnislash runtime is available: agents (any model ref), eval, memory, tools, skills, monitoring, webhooks, scheduler, chat HITL — see features.md for the inventory.

Control model: The developer owns the flow. Every step, every branch, every error handler is code. Agents are called as typed steps within the pipeline — not as autonomous actors deciding the flow.

A Tier 3 pipeline can also call a Tier 1/2 scenario as one durable step: runWorkflow(ctx, scenarioId, input) launches its blueprint run and waits for the run’s terminal (pipelines.md § Helpers API).

When to use: Mission-critical workflows where predictability matters more than flexibility. Compliance-sensitive processes. Complex multi-system integrations. Workflows where “the agent decided to skip step 3” is unacceptable.

Escalation Path

Tier 1                    Tier 2                         Tier 3
"Describe and run"   →    "Lock the blueprint"     →     "Engineer it"

Natural language          Blueprint YAML editing         TypeScript pipeline
AI plans everything       Human freezes structure        Human codes the flow
Agents decide flow        Agents execute locked plan     Code defines flow, agents execute steps
Auto-improve loop         Manual plan iteration          Full engineering control

Escalation is per-workflow, not per-account. A business can have 50 Tier 1 workflows, 10 Tier 2, and 3 Tier 3 — running simultaneously on the same Omnislash instance. All three tiers share the same runtime: database, queues, agent system, tool registry, skills, HITL, observability. Tier 3 adds only the Restate server (a single binary in the compose stack).

Agent calls inside a Tier 3 pipeline — two patterns

The pipeline SDK’s runAgent helper (pipelines.md § Helpers) is the canonical way to call an agent from a pipeline. Two shapes matter:

Short calls (API mode: classification, extraction, scoring) run inside a journaled step. On crash-replay the cached result is returned — the agent does NOT re-execute. Use a structured-output schema to get a typed inter-step contract.
Long calls (CLI mode: coding, research, complex analysis) are dispatched to the agent runtime and awaited on a durable promise. The agent runs independently — it survives a pipeline worker crash, and the pipeline resumes with the result when it lands.

Either way the flow stays in your code; the agent is a step, not the orchestrator.