ExecutionRoom 03 of 13

Give it a goal. It runs the graph.

Sophon Graph runs your request as a durable, concurrent graph: independent steps execute in parallel in isolated sessions, results join cleanly, and work that finished is never redone. A restart brings the run back where it stopped, and hands you the decision to carry on.

Stage 5 of 7. A revised plan that adds the booking step is parked at an approval gate, waiting for a person.

plan v2 parked at the revision gate · waiting for you

Recreation of a Sophon Graph run. Rests on the plan-revision gate.

AWatch a run survive a restart

Forty invoices, one restart, nothing done twice.

A long run is where a loop breaks. Step through a batch job that loses its Gateway halfway, and see what the checkpoint keeps.

A plan card with forty invoice steps, none started.

plan v1 · 40 steps · 0 done

Step 1 of 4: One invoice, one step

01 / 04 · One invoice, one step

  1. Forty invoices become forty steps in one plan. Each is processed in its own fresh, isolated step with a small, clean context, instead of one transcript that grows with every invoice.

Cancel instead, and the run stops. Retry failed steps starts a new run that keeps every completed step with its output and runs only the work that did not finish. The Dashboard previews which steps will run again and warns you when one has side effects.

Plan recovery

BThe mechanism

Why a graph beats a loop.

The old way ran steps one at a time in a single growing transcript. The graph runs independent steps at once, each in a clean context of its own.
Parallel
Independent steps run concurrently. A briefing with three fetches finishes in roughly the time of the slowest one, and a 10-step plan with 3 independent branches completes as fast as the longest branch, not the sum of all steps.
Durable
Every transition is checkpointed, so completed steps are never re-run. If the Gateway restarts mid-step, the run comes back paused and waits for you to resume it; nothing side-effecting is replayed behind your back.
Isolated
Each step runs in its own child session with a small, clean context: no noisy tool output polluting the next step, and lower cost than one ever-growing transcript.

A run, end to end

Every transition below is written to the store the moment it happens, so a restart never repeats finished work.

  1. 01Plancompiled to an immutable, versioned graph
  2. 02Dispatchready steps launch in dependency order
  3. 03Runisolated sessions, in parallel
  4. 04Joingathers distilled outputs, not raw transcripts
  5. 05Approvea plan revision parks the run until you sign off
  6. 06Deliverresults arrive proactively; save the run as a workflow

CDurable approvals

When the plan changes, the run waits for you.

A step that keeps failing gets the plan repaired around it, and a repair that raises the risk, reaches for a new kind of tool, or adds a step with side effects parks the run behind a durable gate. No thread is blocked, no timeout ticks away in memory: the run's entire state is checkpointed.

  • Answer a revision gate from the Dashboard, a push notification, or a numbered chat reply, hours later, not seconds (24h by default, up to 72h).
  • If the Gateway restarts while you're deciding, nothing is lost; the run is still parked when it comes back.
  • No answer? The gate times out and rejects; it never auto-approves.
  • Frozen, completed steps are never re-gated. Only the revised part of the plan asks again.
A revision gate six hours into its 24h window. It survived a restart.

DPlanning pipeline

Planning decides what runs. Graph decides how.

Every message runs through a pipeline of twelve middlewares. Planning is the seventh, in the outer zone that runs once per message: it decides whether your request needs a plan, writes one, gets it approved, and hands it to the graph.

When a request gets a plan

Four planning modes, set per agent or per request.

This choice is whether to plan at all. It is separate from the execution mode, which decides how an approved plan runs and has exactly two values, Graph and Classic.

Auto
The default. A heuristic classifier scores the message; a score of 3 or more plans it.
LlmDecides
A fast-tier model is asked whether the request is complex. Falls back to the heuristic on error.
Always
Every request gets a plan.
Never
Planning is off; the request runs in the flat agentic loop.

The Auto heuristic

Signals the Auto classifier scores
Message longer than 100 characters+1
Sequencing words: “and then”, “after that”, “first”, “then”+2
Multi-step words: “steps”, “plan”, “sequence”+2
Two or more action verbs (search, create, send, write)+1

A score of 3 or more plans the request. Planning is skipped when the pipeline is already three levels deep, so a plan step cannot nest plans forever.

What a plan looks like

A goal plus a graph of steps.

Each step carries an id, a description, the steps it depends on, suggested tools, an estimated risk level, and optionally a model hint. A step that asks for reasoning is routed to a model that advertises it, or errors rather than silently falling back.

An example plan for the request: Check my calendar for tomorrow, find relevant Confluence pages for each meeting, and send me a prep briefing on WhatsApp. Step 1 fetches tomorrow's calendar events and step 2 searches Confluence, with no dependencies. Step 3 summarizes both into a briefing. Step 4, at Medium risk, sends it to WhatsApp. The plan waits for Approve, Edit plan or Reject.

Steps 1 and 2 have no dependencies, so they run in parallel. Step 3 waits for both. In an interactive session the whole plan waits for you before step 1 runs.

Requests that plan

  • Morning briefing4 steps · 3 parallel

    Check calendar, scan emails, summarize news, send a digest to WhatsApp

  • Customer onboarding4 steps · 2 parallel

    Create a Jira ticket, set up a calendar invite, draft a welcome email, update the CRM

  • Code review4 steps · 1 parallel

    Pull the PR diff, run the linter, analyze changes, post review comments on GitHub

  • Research report5 steps · 3 parallel

    Search the web, scrape sources, extract data, summarize findings, generate a PDF

  • Expense processing5 steps · 2 parallel

    OCR a receipt photo, extract amounts, categorize, create a spreadsheet, email finance

  • Incident response4 steps · 2 parallel

    Check system health, gather logs, search the Confluence runbook, draft a status update

Approval inside a plan

You approve once, up front.

Plan approval is up-front: you approve the whole plan before anything runs and are not interrupted step by step. Three things can still ask for you mid-run.

The plan gate
Interactive sessions gate the entire plan by default (Always). The other values are ElevatedRisk, where only plans with a step at Medium or above wait, and Never. A session can override the host value. Unattended runs (heartbeat, cron, subagent, webhook) auto-proceed past the plan gate; their individual steps still gate on their own when a call reaches the threshold, and always at Critical.
Edit before it runs
Approve, reject, or edit the plan; with no answer in 10 minutes it is rejected. In the Dashboard, Edit Plan opens a step editor on the plan card itself: change descriptions, remove steps, or reorder them.
A plan revision
One that raises risk, adds a new tool family, or adds a side-effecting step is parked durably, as above.
A tool approval or a question
Raised inside a running step, for a call above the step's auto-approve ceiling or as a question to you. Both are mirrored into your main conversation (Dashboard, Mobile, CLI, and the channel the conversation came from), tagged with the step, and the plan card flips that step to waiting. They wait in memory on a short timer: an unanswered approval is rejected, an unanswered question tells the step to proceed on its best judgment.

When a step fails

A single failure doesn't cancel the plan.

Plans fail gracefully and recover on their own where they can. Repairs are bounded; you get partial results instead of nothing.

Retry with a new approach
The error goes to a fast-tier model, which suggests an alternative approach, and the step is retried once with it. No blind repetition. If there is no alternative, or the retry fails too, the step is marked failed.
Repair the plan
When a step keeps failing, just that subgraph is revised into a new immutable version of the plan while finished steps stay frozen. The plan card shows a version badge.
Smart cascade
Steps that depended only on the failed step are skipped; a step with other completed dependencies can still proceed with partial context. Unrelated steps continue, and nothing upstream is rolled back.
Cancellation
Pressing Stop, or sending a newer message that replaces the turn, stops new dispatches; in-flight steps stop at their next cancellation point. A graceful Gateway stop and the turn time limit pause the plan instead.

Watching it run

Every step, live, on every client.

The engine emits status events over SignalR, and the Dashboard, Mobile and the CLI render them as each step ticks from pending to running to done. A revised plan replaces the step list in place. Step sessions appear under their conversation as Agent activity, and each step links to its own session; steps do not stream their tokens into the main chat.

  • plan_start
  • plan_step_start
  • plan_step_retry
  • plan_step_complete
  • plan_step_failed
  • plan_step_skipped
  • plan_updated
  • plan_interrupted
  • plan_complete
  • plan_failed

EGuardrails

Guardrails, on by default.

Parallel steps need hard limits, and every run gets them.
Run budget
Every plan run carries a $2.00 default cost cap and a 1,500,000-token backstop, checked between steps. A breach stops dispatching and names the limit it hit; steps already in flight finish first, so spending lands near the cap. Since v2.1 the stopped run is paused, not failed, and you can continue it with a new budget. A run whose last wave crosses the cap finishes with its answer. Sub-agent delegation graphs are held by the token backstop alone.
Injection boundary
A step never sees the parent conversation. Dependency outputs arrive wrapped and clearly marked as untrusted.
Taint-aware approvals
Plan steps that touched the open web lower the auto-approve ceiling for whatever consumes their output; riskier actions then need a human.
Loop detection
Inside a step's agentic loop, a detector watches the last 30 tool calls for repeated calls, polling with no progress and A→B→A ping-pong. Warnings steer the model away; 30 repeats trip a circuit breaker that stops the loop.
Step wall clock
Each step in a graph runs against a 30m wall clock.
See how your data stays yours

FKeep it

Liked that run? Keep it.

One click exports a completed run's graph to the visual workflow builder; tweak it, put it on a schedule, and run it again. A conversion note lists anything that doesn't translate 1:1.

Plans made by scheduled, heartbeat and webhook automations run on Graph like any other, so a saved run keeps the same checkpoints.

Open the workflow builder

GExecution modes

Graph and Classic. Your call, per conversation.

Graph is on by default. Switch any conversation with the in-chat pill in the composer, set your own default in Settings → Execution, or use /mode in the CLI. Admins set the workspace default, and the ceiling.

Execution-mode pill in the Dashboard composer
This conversation
/mode graph, /mode classic, /mode default in the CLI
This session
Settings → Execution
Your personal default
Settings → Execution (admin panel)
The workspace default, and the ceiling

Classic, the previous step-by-step engine, stays the opt-out, per conversation or host-wide with Sophon:GraphRuntime:Enabled=false. An admin turning Graph off for the workspace puts everyone on Classic regardless of their own preference.

Limits

What the graph doesn't promise.

  1. Graph drives a run from one Gateway instance. Scale the machine, not the replica count.

    Planning: limits
  2. Only plan revisions wait durably. A tool approval or question inside a running step waits in memory for up to 15 minutes, and a Gateway restart fails that step attempt so it retries.

    Approval gates
  3. A restart does not resume a run by itself. Chat-plan steps are assumed to have side effects, so a run that was mid-step comes back Interrupted and waits for you to press Resume or Cancel.

    Plan recovery
  4. Classic mode has no checkpointing and no durable gates, and a crash mid-run ends that run. A plan made inside a plan step or a sub-agent always runs Classic.

    Graph or Classic
  5. Plan recovery covers chat plans on Graph only, not Classic plans or agent.delegate graphs. Mobile can show a paused plan but cannot resume or retry it yet.

    Plan recovery
  6. A dedicated engine reference lands in an upcoming release. Until then, Planning covers how a plan is compiled, run, checkpointed, and revised.

    Planning

Put the graph to work.

Install Sophon, connect a model, and give it a goal. The Personal tier is free for individual, non-commercial use.