RHONE
>_
{ }
( )
</>

Stateful AI Gateway

Build AI products on durable runs.

Rhone turns model calls into stateful, observable, governable workflows: streamed sessions, live audio, product history, tool execution, evals, and hosted or local harnesses through one runtime.

Start buildingView API
streamed-run.go
1stream := client.Runs.Stream(ctx, vai.RunCreateParams{
2 SessionID: "sess_support_123",
3 Model: vai.ModelGPT5_5,
4 Input: "Investigate this ticket and draft the reply.",
5 Tools: []vai.ToolRef{
6 vai.NativeTool("web_fetch"),
7 vai.PluginTool("crm.search"),
8 },
9})
10defer stream.Close()
11
12for stream.Next() {
13 render(stream.Event())
14}
15if err := stream.Err(); err != nil {
16 return err
17}

Session timeline

sess_support_123 / run_48a

streaming
00:00
run.started

support_triage_v1 on smart-general

00:01
response.delta

streamed to product UI

00:03
tool_execution

crm.search routed through gateway policy

00:05
checkpoint

approval requested before external write

00:09
assessment

quality and policy scores attached

TTFT

310ms

Cost

$0.041

Quality

pass

Runtime primitive

session -> run

Transports

SSE + WS + live

Record

traces + product DB

Durable runtime

Model APIs give you calls. Rhone gives you workflows.

A production AI product needs continuity, streaming, tools, checkpoints, feedback, and replayable history. Rhone makes those first-class runtime objects instead of app-side glue code.

Execution runtime

Stream durable work instead of stitching stateless calls together.

sessionsrunscallstool executionscheckpoints

Product database

Use the same records for rendering, support, analytics, review queues, and export.

timelinesblockshistoryfeedbacksaved views

Evidence layer

Read traces and assessments from the canonical objects that produced them.

observabilityevalsannotationsexperimentstelemetry

Product database

Your AI system of record.

Every session, run, call, tool execution, checkpoint, feedback signal, annotation, and assessment is stored as a product record. Render current state, inspect traces, build review queues, and export evidence without inventing a second storage model.

Read
GET
/v1/sessions/{id}/timeline

Full conversation timeline for rendering

GET
/v1/sessions/{id}/blocks

Active continuity head — what the model sees next

Query
POST
/v1/data/sources/{source}/query

Structured queries over sessions, runs, and calls

GET
/v1/data/views/{id}/results

Named saved views for dashboards and review queues

Annotate & Assess
POST
/v1/annotations

Label, review, and curate any run or session

GET
/v1/runs/{id}/assessments

Machine quality scores attached to every run

Export
POST
/v1/data/exports

Export to Parquet, JSONL, or CSV for your warehouse

product-db.ts
1import { Rhone } from "rhone";
2
3const rhone = new Rhone({ apiKey: "rhone_sk_..." });
4
5const timeline = await rhone.sessions.timeline("sess_support_123");
6renderConversation(timeline.entries);
7
8const rows = await rhone.data.sources.query("run_summaries", {
9 filter: { and: [
10 { field: "assessment_outcome", op: "eq", value: "fail" },
11 { field: "primary_resolved_model", op: "eq", value: "gpt-5.4" },
12 ]},
13 sort: [{ field: "started_at", direction: "desc" }],
14});
15
16await rhone.feedback.create({
17 target: { kind: "run", run_id: rows[0].run_id },
18 signal: "needs_review",
19});
live-session.ts
1const live = await rhone.live.connect({
2 session_id: "sess_voice_123",
3 model: "smart-voice",
4 input_audio: { stt: "auto" },
5 output_audio: { tts: "auto", voice: "alloy" },
6});
7
8live.sendAudio(microphoneFrame);
9
10for await (const event of live.events()) {
11 render(event); // speech, text, tools, checkpoints
12 record(event.run_id); // same session/run model
13}

Live runtime

Voice is part of the same session.

Rhone brings realtime text, live audio, cross-provider STT, and cross-provider TTS into the same durable runtime. Voice sessions produce the same timeline, traces, tool records, checkpoints, and feedback objects as text runs.

Stream

SSE and WebSocket events for text, lifecycle, tools, and checkpoints.

STT

Normalize speech-to-text across admitted providers and project policy.

TTS

One output audio contract for provider voices, format, and latency controls.

Live

Low-latency audio sessions with the same durable run evidence.

Harness model

Governed harnesses for real agents.

Applications configure work. Harnesses implement orchestration. Execution targets perform side effects. Rhone owns the session state, capability snapshot, audit trail, and approvals.

Harness runtime

Where orchestration runs.

  • hosted
  • local
  • external

Execution target

Where side effects happen.

  • workspace VM
  • browser
  • client machine

Event surface

Where humans observe and control.

  • web app
  • SDK
  • operator console

Placement contract

Move orchestration without moving authority.

The same run can use a hosted harness, a local target, a browser surface, and gateway-mediated tools without letting hidden harness state become product state.

await rhone.session("sess_123").run("Refactor auth and open a PR", {
  harness: rhone.harness.hosted("codex"),
  target: rhone.target.workspace("gateway-dev"),
  capabilities: [
    rhone.cap.tool("bash", { approval: "approve" }),
    rhone.cap.mcp("github", { tools: ["pulls.create"] }),
    rhone.cap.skill("gateway-hardening@1"),
  ],
});

Governed capabilities

Every capability resolved and recorded.

Tools, MCP servers, Skills, memory, vaults, safety, evals, and compaction are not ambient extras. Rhone resolves them into immutable per-run capability snapshots with grants, denials, downgrades, policies, and materialization evidence.

Authority receipt

capability_snapshot_id: capsnap_123

Future configuration can change. This run's authority proof cannot.

Tools

Gateway-native, provider, plugin, and target tools recorded as durable executions.

Client tools

Application-owned local work with same-run pause, result submission, and resume.

MCP

Project-bound tools, resources, and prompts resolved into run-scoped grants.

Skills

Procedural context, references, assets, and governed scripts without ambient drift.

Memory

Provider-backed memory reads and writes with policy, provenance, and approval.

Vaults

Obsidian, Logseq, docs, and knowledge stores as governed resource surfaces.

Safety

Action policy, checkpoints, subject scope, credentials, and audit decisions.

Evals

Assessments attached to production runs without contaminating session lineage.

Compaction

Preview and apply controlled history transitions with lineage preserved.

Compatibility

Use the model stack you already have.

Rhone should not force a framework rewrite. Start with gateway-compatible calls, then adopt stateful runs, product history, harnesses, and governed capabilities as the product needs them.

Models

OpenAI, Anthropic, Gemini, Kimi, and project aliases through one routing layer.

APIs

First-party VAI plus OpenAI, Anthropic, and realtime compatibility surfaces.

SDKs

Go, TypeScript, Python, Rust, REST, SSE, WebSocket, and live audio.

Providers

  • OpenAI - Responses
  • OpenAI - Chat Completions
  • Anthropic - Messages
  • Gemini - Contents

SDKs

  • TypeScript
  • Python
  • Go
  • Rust

Transports

  • REST
  • SSE
  • Websocket
  • Live Audio

Ready to build?

Get your API key and start routing to any model in minutes.

Get API keyAPI reference