How the sausage is made
A look under the hood, with no hand-waving.
Behind the simple text thread is a system designed to act, not just answer. An orchestrator routes work across specialized agents, a virtual filesystem gives them shared memory, and a strict harness keeps every action observable and reversible.
ORCHESTRATOR · AGENTS · FILESYSTEM · TOOL USE · HARNESS
SIGNAL
Your text
ORCHESTRATOR
Router & planner
Reads intent, plans, delegates.
AGENT
Email agent
AGENT
Calendar agent
AGENT
Research agent
AGENT
Comms agent
STATE
Virtual filesystem
Durable memory and shared context every agent reads and writes.
01The orchestrator
One brain that delegates, instead of one model that guesses.
The orchestrator is the part of Poke that thinks about thinking. It never tries to hold the whole world in one place - it breaks intent into tasks and routes them to agents built for the job.
Plan before act
Every incoming signal becomes an explicit plan: what the goal is, which agents to involve, and what done looks like. Plans are inspectable, not implicit.
Delegate to specialists
Rather than one giant context trying to do everything, the orchestrator hands narrow, well-scoped tasks to agents that are good at exactly one thing.
Compose results
Agent outputs flow back through the orchestrator, which reconciles them, resolves conflicts, and decides whether to act, ask, or keep watching.
02The virtual filesystem
Memory you can point at.
Context windows forget. A filesystem doesn't. Poke keeps its working state as a structured, file-like store that every agent can read and write - so memory is durable, addressable, and easy to reason about.
Structured, not a blob
Facts, live context, and per-task scratch space each live in their own place, with clear ownership and lifetimes.
Durable across turns
What Poke learns about you persists between conversations - it doesn't relearn your preferences every morning.
Scoped and auditable
Every read and write is attributable to an agent and a task, so the state behind any action can be traced.
- /root
- memory/durable facts & preferences
- you.mdhow you write and decide
- people/who matters, and how
- context/live working set
- inbox.snapshotcurrent email state
- calendar.snapshotnext 14 days
- scratch/per-task workspace
- task-4f2a/draft + reasoning
03Tool use
Actions are typed, validated, and logged.
Agents don't reach into the world freely. They call tools - a constrained set of typed operations with clear inputs, outputs, and permissions. Every call is checked before it runs and recorded after, so nothing happens that can't be explained or undone.
Typed contracts
Each tool defines exactly what it accepts and returns.
Permission gates
High-impact actions require explicit confirmation.
Reversible by default
Where it matters, every action has a defined undo.
Idempotent calls
Retries can't double-book or double-send.
- ok
calendar.find_slot
duration=30m, window=this_week
- ok
email.draft
to=partners@…, re=reschedule
- ok
email.send
draft=d_91, confirm=true
- ok
calendar.create
title=Prep, 14:00–14:30
04The harness
The model is one part. The harness is what makes it dependable.
Poke is deliberately model-agnostic. The reasoning engine is swapped and upgraded as the field moves; what stays constant is the harness around it - the scaffolding that turns raw capability into a trustworthy assistant.
Context assembly
Pulls exactly the right slice of memory and live state into each agent's view - no more, no less.
Guardrails
Policy checks, rate limits, and confirmation gates wrap every action the system can take.
Observability
Plans, agent steps, and tool calls are traced end to end, so any outcome can be replayed.
Recovery
When a step fails, the harness retries safely, rolls back, or escalates to you - never silently breaks.
05Principles
What we optimize for.
- Reliability over cleverness
- A correct, boring action beats an impressive, risky one. The system is tuned to be trusted, not to show off.
- Reversible by construction
- If an action can't be cleanly undone or confirmed, it gets a gate. Surprises are bugs.
- Model-agnostic core
- The harness, filesystem, and tools are the durable assets. The reasoning engine underneath can change without touching them.