PULSE OS-010 GitHub →

OS-010 · the temporal algebra of the [&] stack

Every loop has a rhythm.
PULSE is how it
declares one.

PULSE is the temporal manifest standard for closed-loop systems. A loop's phases, cadence, nesting, substrates, invariants, and cross-loop signal connections all live in a single *.pulse.json file. Conforming loops become automatically PRISM-evaluable, plug into Graphonomous, and circulate cleanly with any other PULSE-aware system.

Install os-pulse → Read a Manifest Open Sentience
§00 · the name

PULSE

  1. Protocol
  2. Uniform(for)
  3. Loop
  4. State
  5. Exchange

Protocol for Uniform Loop State Exchange. One vocabulary for how every loop in the [&] ecosystem declares its rhythm, circulates state, and hands off signals to its neighbors — so any system can interoperate without bespoke integration.

§01 · the five canonical phases

Every loop. Five phases. One algebra.

PULSE crystallizes a decade of agent-loop folklore into five canonical phase kinds. These are the same phases Graphonomous uses for memory and PRISM uses for benchmarking — because the underlying rhythm is the same.

  1. 01 Retrieve Pull context from substrates before reasoning. Read paths only.
  2. 02 Route Decide whether to act, deliberate further, or escalate.
  3. 03 Act Mutate substrate or external system. The only side-effecting phase.
  4. 04 Learn Close the feedback loop with outcome signals and confidence updates.
  5. 05 Consolidate Maintain substrate health at session boundaries.
§02 · one file describes a loop

Loops declare themselves. The runtime trusts the manifest.

What's in a *.pulse.json

A PULSE manifest tells the runtime — and any observer — exactly how the loop ticks. The schema is JSON Schema draft 2020-12 and ships with twelve conformance tests.

  • phases — ordered phase signatures, each typed by kind.
  • cadence — invocation rate, idle policy, jitter.
  • substrates — what state the phases read or write.
  • invariants — atomicity, idempotency, monotonicity claims.
  • connections — cross-loop signal edges.
  • nesting — child loops and how they wait on their parent. 
"loop_id": "graphonomous.continual_learning",
"version": "0.4.0",
"phases": [
  { "kind": "retrieve", "name": "context" },
  { "kind": "route",    "name": "deliberate?" },
  { "kind": "act",      "name": "store_node" },
  { "kind": "learn",    "name": "from_outcome" },
  { "kind": "consolidate", "name": "merge" }
],
"cadence": { "on": "invocation", "idle": "sleep" },
"substrates": ["sqlite_kg", "sqlite_vec"],
"invariants": ["act.atomic", "learn.idempotent"],
"connections": [
  {
    "to": "prism.benchmark",
    "emits": ["OutcomeSignal", "TopologyContext"]
  }
]  // ↑ a loop fragment from the reference manifest
§03 · cross-loop signals

Five canonical tokens. Wrapped in CloudEvents.

When loops talk to other loops, the payload is one of five typed tokens, wrapped in a CloudEvents v1.0 envelope. This is how Graphonomous tells PRISM "I'm ready to be benchmarked," and how PRISM tells Graphonomous "your κ-routing got worse this cycle."

TopologyContext

A snapshot of structural state — graph subset, κ value, current goals.

DeliberationResult

The output of a route phase: chosen action, alternates, and confidence.

OutcomeSignal

Did the action succeed? Decoupled from any specific reward function.

ReputationUpdate

Cross-loop adjustments to a system's standing — who to trust next time.

ConsolidationEvent

A substrate maintenance pass completed; observers can refresh their caches.

§04 · loops inside loops

Triple-nested cadence in a single declaration.

PULSE makes loop nesting first-class. A child loop declares its parent and how it waits — every phase, every connection becomes traceable across nesting depth. This is what unlocks the [&] triple loop: structural composition, diagnostic measurement, and temporal manifest in one stack.

Three loops, one circulation.

The outermost loop is the PRISM benchmark cycle — slow, deliberate, cycle-scoped. Inside it runs the Graphonomous memory loop — fast, per-task. Inside that runs the deliberation loop — bursty, only when κ-routing demands it.

Each loop has its own cadence and its own manifest. PULSE is what keeps them in sync without forcing them into the same timestep.

§05 · by industry

One algebra. Every cadence in your business.

A loop is a loop whether it ticks every 30 seconds or nets once a day. Below, the same five PULSE phase kinds — retrieve ▸ route ▸ act ▸ learn ▸ consolidate — wear five industries. Each host emits a different canonical token over CloudEvents, so a logistics loop and a trading desk become PRISM-evaluable the same way.

Dispatch & fleet ops. Positions in every 30 seconds, re-plan only when demand spikes (κ>0), and ship an OutcomeSignal on every ETA so your routing model is measured, not assumed.

 fleet_dispatch_loop.ex Elixir / PULSE.Loop
cadence tick · every 30s token OutcomeSignal → PRISM invariant κ-routing

End-of-day settlement. Gather the day's trades, net exposure, and post nothing without quorum. A ConsolidationEvent rolls the book to T+1 and feeds tomorrow's treasury forecast.

 ledger_settlement_loop.ex Elixir / PULSE.Loop
cadence cron · 22:00 ET, Mon–Fri token ConsolidationEvent invariant quorum-before-commit

Continuous patient monitoring. A surprise in the vitals stream doesn't auto-commit — it routes to a clinician and emits a SurpriseSignal (the OS-011 forward-model error) so the escalation loop wakes only when it should.

 vitals_monitor_loop.ex Elixir / PULSE.Loop
cadence event · sensor_frame token SurpriseSignal → escalate invariant outcome-grounding

Deploy & incident pipeline. Every gate is append-only audit; risky changes canary first (blast_radius>0); a rollback or SLO breach ships a ReputationUpdate so Delegatic governance learns which changes to trust.

 deploy_pipeline_loop.ex Elixir / PULSE.Loop
cadence event · git_push token ReputationUpdate → Delegatic invariant append-only-audit

Systematic trading desk. A streaming book with a hard 50 ms lag budget. Clear signals fire immediately; ambiguous ones (κ>0) route to a bounded deliberation and come back as a DeliberationResult before the deadline.

 desk_tick_loop.ex Elixir / PULSE.Loop
cadence stream · ≤50 ms lag token DeliberationResult invariant κ-routing

Honest note · these are illustrative reference hosts — a readable PULSE.Loop DSL sketch, not a published library. The conformance-tested surface is the manifest: every loop above serializes to a *.pulse.json validated by os-pulse against the v0.1 schema and the 12-test suite. The five phase kinds and five tokens are the real protocol.

§06 · install

Validate, register, circulate.

os-pulse is the reference MCP server for PULSE. It validates manifests against the v0.1 schema, runs the 12-test conformance suite, and persists registered loops, connections, and CloudEvents envelopes in an embedded SQLite database.

Drop it into .mcp.json, register your loop's manifest, and any PULSE-aware tool — including PRISM — can discover your phases, signatures, substrates, and invariants automatically. 

# 1. install (no global pollution)
$ npx -y os-pulse --db ~/.os-pulse/manifests.db

# 2. validate a manifest before registering
$ os-pulse validate ./graphonomous.continual_learning.pulse.json

# 3. register from any MCP-aware agent
→ register_manifest "./prism.benchmark.pulse.json"
→ trace_connection "prism.benchmark" --depth 3
→ export_topology --format dot

# 4. circulate cross-loop signals
→ emit_signal OutcomeSignal --to prism.benchmark
§07 · open research

PULSE is one clock in an open research program on machine cognition.

OpenSentience publishes the specifications — OS-001 through OS-010 — that turn agent cognition into something you can read, measure, and synchronize. Structured memory. Deliberation topology. Continual learning. Temporal algebra. Every protocol ships as a public document, a reference implementation, and a test.

  • OS-006ampersand protocol — structural composition
  • OS-008agent harness — pipeline enforcement
  • OS-009PRISM — diagnostic loop
  • OS-010PULSE — temporal loop algebra (you are here)
Explore OpenSentience

opensentience.org — open research into machine cognition, published by Ampersand Box Design.