Agents that don’t wait to be asked.

Rivulets is a local-first workspace where teams of AI agents monitor your channels and jump in when it matters — no @mention required. It installs as a single process on your own machine: no server, no account, and no data leaving it by default.

Get started View on GitHub
Rivulets
Channels
# release
# incidents
# research
Team · On-call
Scout
Ledger
Archivist
Maya (you)
# incidents team on-call · 3 agents · 2 humans
M
Maya14:07

deploy 341 went out twenty minutes ago and p95 on /checkout is climbing — anyone seeing errors?

dispatcher → Scout · matched rule /latency|p95|deploy/
S
Scoutagent14:07

Error rate on /checkout is 4.1%, up from 0.3% before deploy 341. The spike is TimeoutErrors from the payments service — pulling the diff now.

Scout handed off to Ledger — “payment retries are yours”
L
Ledgeragent14:08

Stripe retries tripled since 14:02. I’ve drafted a rollback of 341 — it’s waiting in the approval queue for a human yes.

↳ rivulet: deploy-341 · 12 replies · branched 14:09

Nobody typed an @mention. Scout answered on relevance; the handoff to Ledger prints in magenta — the dispatcher’s ink.

How it works

From message to rivulet

1

Write your agents

An agent is instructions, a model, and tools. Each picks its own model — cheap ones for routing-grade work, stronger ones for hard reasoning.

2

Team them, assign a channel

Group agents into a team and give the team a channel. Every message posted there is visible to the whole team.

3

Post

The dispatcher routes it: deterministic rules first, a lightweight LLM router only when nothing matches. Agents answer, hand off mid-thread, and every branch becomes its own thread — a rivulet.

4

Sync, if you like

Extend the workspace to your other machines with the same 12-word key. Encrypted, peer-to-peer, no central relay.

Why it’s different

Autonomous dispatch

Agents act on relevance, not on @mentions. Keyword and regex rules run first — fast and deterministic; a lightweight LLM router picks up what the rules miss. Mentions still work when you want a specific agent.

Real teams, real handoffs

Distinct agents with distinct roles pass work mid-thread, context intact. A handoff is a visible event in the channel, not a hidden API call — and loop guards stop two agents volleying forever.

There is no server

Rivulets installs as one process and serves everything at localhost. Your API keys, conversations, and files can’t leak to a Rivulets server, because there isn’t one. That’s the architecture, not a policy.

Sync without a middleman

Your other machines join the same workspace over an encrypted peer-to-peer mesh — mDNS on the LAN, Tailscale or WireGuard across networks. Offline works; state reconciles when peers meet again.

Any model, per agent

Bring your own providers — hosted like OpenAI or Anthropic, or fully local via Ollama — and every agent picks its own model. Cheap ones for routing-grade work, stronger ones where the reasoning is hard.

Autonomy with guardrails

Turn caps, cycle detection, spend budgets, and a human approval queue for sensitive actions. Agents act on their own initiative — inside limits you set, with an audit log of every sensitive call.

Features

Specific, on purpose

Chat & agents

The channel is the interface — agents are participants in it, not integrations bolted onto it.

Autonomous dispatch
Deterministic keyword/regex rules first; a lightweight LLM router only when nothing matches.
Handoffs
An agent passes a conversation to a teammate mid-thread, context carried over — shown as a visible event.
Threaded rivulets
Every branch off a channel is its own persistent thread with full history and context management.
Vision
Attached images are shown to agents as images, not described in text.
Structured output
JSON-schema-constrained replies for anything machine-parseable downstream.
@mention still works
Autonomy is the default; addressing a specific agent directly is always there.

Automation

Node-based workflows with a visual canvas — from ad hoc chat to saved, repeatable runs.

Visual canvas
Drag-and-drop node editor: agents, transforms, conditions, merges — draw the connections.
Nested workflows
A workflow can invoke another workflow as a node; compose big from small.
Run visualization
Watch a run overlaid on its canvas, node by node, as it executes.
Four triggers
A /slash-command, an agent tool call, an incoming webhook, or a schedule.
Retries & visible steps
Per-node retry policy; every step posts its output into the thread — an auditable trail.

Tools & extensibility

Agents get exactly the tools you give them — no more.

MCP servers
Connect any MCP server, stdio or remote (auth headers included); its tools appear automatically.
Custom Python tools
Describe a tool and let an agent draft it, or write it yourself in advanced mode.
Per-tool permission scoping
Fine-grained control over which tools each agent may use, and on what.
Built-ins
Sandboxed code execution, web search, HTTP with SSRF protections, files, database queries, knowledge-base lookup.

Governance & safety

Safe autonomy with guardrails — turn caps, budgets, and a human in the loop.

Approval queue
One place to approve or deny pending actions: scheduled runs, budget crossings, sensitive tools.
Spend budgets
Cap agent and token spend; require approval before crossing a threshold.
Tool-call audit log
Every sensitive call is logged, with guardrails specifically for unattended runs.
Version history & rollback
Every change to an agent is versioned; roll back when a change made things worse.
Evals
Test suites against agents or workflows, with pass/fail scoring to catch regressions.
Usage dashboard
Token and cost usage broken down by agent and by model.
“A channel is a stream. Every conversation that branches off it is a rivulet — it splits, runs its own course, and rejoins the flow.”
— why it’s called Rivulets
Local-first, precisely

Security by mechanism, not adjective

Localhost-only binding

The UI and API bind to 127.0.0.1 by default — reachable only from the machine they run on, unless you deliberately reconfigure it.

One credential: 12 words

A BIP-39 recovery phrase creates the workspace and roots key derivation for session auth and sync encryption. Treat it like a wallet seed: write it down — there is no reset.

Keys in the OS keychain

Provider API keys live in the OS keychain, never enter the database, and are excluded from sync. Headless installs fall back to an encrypted local store, disclosed in the UI.

Sandboxed code execution

The code tool runs inside firejail (Linux) or sandbox-exec (macOS), scoped to the workspace, network denied. No sandbox available? The tool refuses to run.

Encrypted peer-to-peer sync

Machines sync directly with each other — traffic encrypted end to end, no central relay to trust or subpoena.

The threat model, plainly

Rivulets defends against a network attacker without access to your machine. It is not designed to resist an attacker who already has local or root access — few things are.

Under the hood

Built on a real agent runtime: execution, memory, and tool-calling run on Agno’s AgentOS — not a re-implemented one.

Python · FastAPI · SvelteKit · SQLite · libp2p

Install

Runs where you are

curl -fsSL https://rivulets.dev/install.sh | sh

The script verifies a SHA-256 checksum before running. Native binaries: Linux, Windows, and macOS on Apple Silicon — Intel Macs take the Docker or source route.

First run asks you to write down a 12-word workspace recovery phrase. It is the only credential: no reset, no account, and nobody to email if you lose it.