Relavium

Start as an agent. Ship the workflow. Own every run. A multi-surface, local-first AI agent workflow platform — a product of HodeTech.

Relavium meets you where you already work — in conversation — and gives that conversation somewhere to go. You start as an agent: a multi-turn session in your terminal, in VS Code, or in a desktop chat panel. When a flow proves itself, you ship the workflow: export the session to a git-committable, multi-agent, multi-model .relavium.yaml pipeline that runs identically in your editor, your terminal, and your CI. Or author workflows directly. Either way you own every run — every step debuggable, every token and dollar tracked, every artifact yours, nothing leaving your machine unless you choose it.

Why Relavium?

• Four surfaces, one engine. Desktop (Tauri), CLI, VS Code, and (Phase 2) the web portal run the identical pure-TypeScript engine. No Python sidecar, no single-tool lock-in — every surface is a first-class execution target.
• A chat-to-workflow continuum. Other tools make every session ephemeral. Relavium sessions are persistent, resumable, and one-click exportable into a reviewed, committed workflow.
• You own your LLM seam. Multi-provider routing with fallback chains ([claude → gpt-4o → gemini]) is first-class through Relavium's own @relavium/llm abstraction over the official provider SDKs — no Vercel AI SDK, no LangChain.
• Local-first by design. Phase 1 ships with zero cloud and no account required; keys live in your OS keychain. BYOK-local stays first-class forever; Phase 2 adds optional managed inference and cloud execution on the same engine.
• Workflows are git objects. .relavium.yaml files are diffable, reviewable, PR-able, and shareable — team infrastructure, not a proprietary JSON blob or buried Python.
• Multimodal, end-to-end. Image / audio / video as input and output — including rule-driven media generation — flow through the same seam and engine.

Highlights (Phase 1)

• Chat-to-workflow export — turn a proven session into a reusable .relavium.yaml.
• Persistent, resumable agent sessions — no run is ever ephemeral.
• Live execution — tokens stream as the run progresses; parallel branches run together.
• Multi-model fallback chains — runs survive provider outages and rate limits.
• Checkpoint & resume — pause and resume at any node boundary, even across processes.
• Human gates with timeout policy — pause for an approve / reject / input decision.
• Per-node cost waterfall — token and dollar attribution per node, per model.
• Local-first, zero-install posture — BYOK, OS keychain, no sign-up in Phase 1.

Getting started

The CLI is the first usable surface. It ships as a single npm binary — npm install -g relavium (the public npm publish is the final maintainer step of the v0.1.1 release; until it lands, build from source per local dev setup). Then start as an agent → ship the workflow → own every run:

# 1. Point Relavium at a provider — your key goes to the OS keychain, never a file
relavium provider add anthropic
echo "$ANTHROPIC_API_KEY" | relavium provider set-key anthropic   # the key is read from stdin, never argv

# 2. Start as an agent — a multi-turn session in your terminal
relavium chat
#    …converse until a flow proves itself, then run /export inside the REPL
#    to ship the session to a git-committable .relavium.yaml

# 3. Own every run — execute the workflow and stream every event (CI-friendly with --json)
relavium run ./my-workflow.relavium.yaml --json

Prefer to author directly? relavium create scaffolds an agent or a minimal single-agent workflow, and relavium import / relavium export move them between projects. The full surface is the CLI command reference.

Architecture

flowchart TD
    subgraph Surfaces
        D[Desktop · Tauri]
        C[CLI]
        V[VS Code extension]
        P[Web portal · Phase 2]
    end
    subgraph Engine["@relavium/core — one pure-TypeScript engine"]
        WE[WorkflowEngine]
        AS[AgentSession]
        BUS[(RunEventBus · ToolRegistry)]
        WE --- BUS
        AS --- BUS
    end
    SEAM["@relavium/llm seam"]
    PROV[Anthropic · OpenAI/DeepSeek · Gemini]
    D --> Engine
    C --> Engine
    V --> Engine
    P --> Engine
    Engine --> SEAM --> PROV

Loading

One engine, two co-equal entry points — WorkflowEngine (runs YAML pipelines) and AgentSession (runs conversational chat) — sharing the same tool registry, the same @relavium/llm multi-provider seam, and the same event bus. The engine has zero platform-specific imports, so the same source runs in the Tauri WebView, the VS Code host, the Node CLI, and (Phase 2) a Bun server. Supporting packages: @relavium/shared (Zod contracts), @relavium/db (Drizzle — SQLite locally, PostgreSQL in Phase 2), and @relavium/ui (ReactFlow canvas + shadcn). See docs/architecture/.

Execution modes

One engine, three modes behind the one LLMProvider seam:

• Local (BYOK) — Phase 1 default. Your keys, your machine, zero Relavium data.
• Managed inference — Phase 2, opt-in. Relavium's metered keys; the engine still runs locally.
• Cloud execution — Phase 2. Run workflows on cloud workers for 24/7 automation and team sharing.

Status

Phase 1 — Engine and LLM is complete (2026-06-21): the engine runs end-to-end on local-first BYOK — workflow parsing, DAG execution, live streaming, checkpoint/resume, multi-provider failover, cost governance, and multimodal media I/O. Phase 2 (the CLI) is feature-complete — the CLI skeleton, config resolution, relavium run (wired to the engine), its --json CI machine-output contract, the engine regression harness, durable local run history, the provider/key commands (API keys in the OS keychain), the live ink streaming TUI, the human-gate prompt + out-of-band relavium gate resume, the read commands (list / logs / status / gate list) over durable history, and the published, cross-OS-installable npm i -g relavium binary (packaging & install verification) have landed (milestone M3 reached; with packaging shipped, all seven Phase-3 go/no-go exit criteria now hold). The first additive lanes have since landed too — media host-wiring (a generative media-output fixture runs end-to-end on the CLI); the full agent-first chat family: the relavium chat REPL plus session resume / list / export, a headless chat --json event stream, and a one-shot agent run with deterministic offline --fixture replay (the first user-facing AgentSession surface); and the inbound MCP client — agents consume external MCP servers' tools over stdio + the http/sse/websocket network transports (behind an SSRF floor and isolated keychain-resolved secrets), proven by a real-spawn end-to-end test; and the YAML-authoring lifecycle — relavium create (a wizard scaffolding an agent or a minimal single-agent workflow), import, and a share-safe export (re-serialized from the validated AST, no provider key by construction). With every in-phase workstream merged, the CLI is cut as v0.1.1 (the public npm publish is the pending final maintainer step). For live status and the full roadmap, see docs/roadmap/current.md and the roadmap.

Documentation

The canonical documentation lives in docs/ — start at docs/README.md, which is organized by the kind of question each section answers.

Start here
Vision · Product constraints · UVP	What and why
Tech stack · Project structure	What it's built with
Architecture · Decisions (ADRs) · Reference	How it works
Roadmap · Standards	Where it's going, and the rules

License

Relavium is proprietary software — © 2026 HodeTech, all rights reserved. It is not open source and grants no rights except as expressly stated. See LICENSE for the full terms. For licensing inquiries, written permission, or commercial-use agreements, contact HodeTech.