Continuum

Orchestrate the handoff, not the chaos.

Comment

Inspiration

Interfacility transfers, especially time-critical paths like stroke, depend on coordination across organizations, not a single EMR screen. Rural ED, stroke center, payer, and pharmacy each bring policies, payloads, and proof that something happened. In the real world that still means faxes, phone tags, and opaque handoffs. When the clock is neurological, delay is harm.

We wanted a demo that treats agent-to-agent (A2A) coordination as something you can see and trust: who is in the mesh, what messages moved, which tool calls fired, and what landed in an audit trail, instead of one chat bubble pretending to be the hospital.

Continuum is that command center: a bridge from "describe the transfer in plain language" to "watch the handoff orchestrate itself on the record."

What it does

  • Care handoff in plain language. A chat landing lets you describe a patient and transfer; the Conductor routes that intent into structured orchestration. An offline demo path keeps the mesh runnable for judges without API keys.
  • Live A2A mesh. A force-directed graph shows Conductor plus agents (Sentinel, Atlas, Ledger, Apothecary): nodes appear over time, curved links show protocol-style edges (message, input-required, auth-required, and similar), optional edge labels, zoom and pan, refresh and fit.
  • Tool-call sub-nodes. Short-lived tool nodes (for example NIHSS scorer, bed checker, prior auth) attach to parent agents; click for input and output detail.
  • Operational UI. Step cards with status, metrics, progress, and task checklists; split, graph, and workbench layouts; patient and context chips when live data supplies them.
  • Audit trail. Timestamped events stream as the run advances so accountability reads as a product surface, not an afterthought.
  • Demo plus live modes. "Simulate Maria Transfer" drives a scripted Maria Thompson stroke narrative to completion. Optional live Conductor mode discovers A2A from agent-card.json, streams JSON-RPC or SSE, and projects the run into the same dashboard.

How we built it

Layer Stack
App React 19, TypeScript, Vite 8
UI Tailwind CSS v4, Radix slot, CVA, Lucide
Graph react-force-graph-2d plus custom canvas painting for links and nodes (active vs complete edges, tool styling, spawn beam)
State Central simulation.ts timeline; live path via conductor.ts and useConductorSession (card discovery, message send or stream, SSE parsing)
Safety Vite dev proxies so API keys can stay server-side in local dev (CONDUCTOR_API_KEY in .env.local, not bundled for the browser)
Resilience Root error boundary so a render failure shows a message instead of a blank screen

We kept one source of truth for narrative timing and graph structure where we could, and split presentation (mesh, cards, audit) from transport (Conductor fetch and stream).

Clone and run locally:

git clone https://github.com/Manoj7ar/Continuum.git
cd Continuum
npm install
npm run dev

Optional live Conductor: copy .env.example to .env.local, then follow the README for VITE_CONTINUUM_LIVE_CONDUCTOR, proxy flags, and key variables.

Challenges we ran into

  • Canvas and React refs. The force-graph ref only exposes a fixed method set. Calling APIs that are not on that list broke ticks and zoom. We synced graph data through a ref that tracks the latest props so fit-to-view and position sampling stay reliable.
  • CORS and secrets. Browsers cannot safely attach API keys to some Conductor hosts from client-only JS. Vite middleware proxies in local dev let demos stay honest without baking secrets into the bundle.
  • Streaming differences. SSE, JSON-RPC shapes, and host quirks (for example SendMessage vs spec-style methods) needed a small adapter layer instead of one happy path.
  • Trust UX. Making busy orchestration legible (legend, labels, tool fade, audit) without hiding how messy real coordination is.

Accomplishments that we're proud of

  • A cinematic but grounded story: Maria Thompson end-to-end with a "transfer complete" payoff that reads as ops, not sci-fi.
  • A mesh that feels alive: staggered spawn, tool satellites, and edges that read as protocol, not decoration.
  • Split view that fits graph, work, and audit in one viewport for demos and judging.
  • A live path that reuses the same dashboard: discovery from the agent card, stream handling, projection into cards, graph, and audit.
  • Branding that matches the metaphor: B&W mesh mark, favicon, and a wordmark that weaves the icon into the product name.

What we learned

  • Orchestration UX is as hard as orchestration code. People need time, identity, and causality on screen at once.
  • Demos need a deterministic spine (offline simulation) next to a credible live spine so judges never hit a dead end.
  • A2A fits regulated handoffs better than "one omniscient model": specialists, router, and audit match how risk is actually managed.

What's next for Continuum

  • Durable runs. Persist sessions, replay timelines, and export audit packets (PDF or JSON) for demo-to-pilot conversations.
  • Richer clinical context. Deeper FHIR or SHARP surfaces and diffable payloads as streams stabilize.
  • Role-based views. ED vs stroke center vs payer lenses on the same underlying graph.
  • Hardening. Auth for Conductor, rate limits, and production hosting without dev-only proxies.
  • Evaluation. Side-by-side latency and handoff completeness metrics against scripted golden paths.

Built With

Share this project:

Updates