REACH + OCTO

Appearance

What is OCTO? ​

OCTO — On-demand Contextual Task Orchestrator.

A multi-arm orchestration pattern built on REACH. Where REACH is a single intentional dive into one source, OCTO coordinates multiple arms simultaneously — each reaching independently, the combined signal surfacing a contextual decision interface at the moment that matters.

Named after the octopus: eight arms, each semi-autonomous, coordinated by one intelligence. The arms find. The octopus decides.

The Octopus Metaphor — Why It's Accurate ​

The octopus has eight arms and a central brain — but 2/3 of its neurons live in the arms, not the brain. Each arm acts semi-autonomously. The central brain holds intent and reads the combined signal.

OCTO maps this exactly:

  • Each arm is a REACH — diving into a source, surfacing with findings
  • Arms act independently, don't know what the others found
  • OCTO holds the combined signal, reads across all arms
  • OCTO generates the surface for this moment — not pre-built, authored from findings

The name is for the metaphor, not a hard count. OCTO doesn't enforce eight arms.

The Arc ​

Intent declared
  ↓
Arms reach simultaneously
  outlook.inbox    →  urgent items
  teams.planner    →  overdue tasks
  teams.transcript →  last meeting summary
  git.commits      →  what shipped yesterday
  ↓
OCTO reads combined signal
  ↓
Contextual surface generated — authored for this moment
  ↓
Human decides
  ↓
Arms act on the decision
  ↓
OCTO closes — warm, with personality

The surface is not a pre-built form. It is generated by Claude for this specific run — the right title, the right items, the right actions, based on what the arms actually found.

REACH vs OCTO ​

REACH  →  the language
           single arm, one source, one output
           dotnet run task.cs
           reach outlook.inbox where subject contains "[PROJECT]"

OCTO   →  the orchestrator
           multiple arms, combined signal, decision surface
           morning.octo, deploy.octo, review.octo

REACH is the vocabulary. OCTO is the sentence. OCTO is built from REACH reaches composed together. Neither replaces the other.

The Morning Brief — The Demo That Matters ​

The canonical OCTO demonstration. Four arms. One surface. One decision. One joke.

08:45 — morning.octo runs

Arms reach simultaneously:
  outlook.inbox    → 3 flagged items, 1 urgent thread
  teams.planner    → 2 overdue, 1 due today
  teams.transcript → last standup: deployment mentioned
  git.commits      → 2 commits yesterday, on track

OCTO reads combined signal:
  Urgent: Sarah emailed twice, no reply
  Overdue: project planner item 3 days past due
  Context: deployment discussed in standup

Surface appears:
┌──────────────────────────────────────────────┐
│  Good morning. Here's what needs you.        │
│                                              │
│  🔴 Sarah emailed twice — awaiting reply     │
│  🟡 Project planner item — 3 days overdue    │
│  📋 Deployment flagged in yesterday's standup│
│                                              │
│  [Draft reply to Sarah]                      │
│  [Send morning summary to team]              │
│  [Snooze planner item]                       │
│  [Show me everything]                        │
└──────────────────────────────────────────────┘

[Draft reply to Sarah] chosen

REACH reads the full thread
Claude drafts contextual reply
Preview surfaces — one line edited, sent

OCTO closes:
  "Sarah will appreciate that.
   One less thing before your first meeting.

   Also — your commit streak is intact. Respectable."

8:52am. Day begins.

Human-First by Design ​

Most agentic frameworks treat human input as an edge case — an approval step added when you're nervous about full automation. The goal is always to remove it eventually.

OCTO treats human judgment as a first-class architectural primitive.

The decision surface isn't a safety valve. It's the design. The methodology explicitly reserves space for human judgment at the moment it matters — not because the system can't proceed, but because that moment belongs to the human.

Enterprise framing:
  Human → bottleneck to route around
  Goal  → full autonomy

OCTO framing:
  Human → irreducible element that makes output meaningful
  Goal  → right altitude, right moment, right context assembled

What OCTO Is Not ​

  • Not an agent framework — no role definitions, no agent topology
  • Not a workflow engine — no node graphs, no visual builders
  • Not a chatbot — not conversational, task-oriented
  • Not a dashboard — surfaces appear and disappear, nothing persists on screen
  • Not infrastructure — no server, no always-on process, no install

OCTO is a pattern. A .octo file is the artifact. Claude is the conductor. Your machine is the stage.

Next ​