ifuri · urirun

Connect apps through URI.

Any process as an MCP / A2A service, by URI. A local-first runtime for flows, devices, agents and LAN services.

ifuri.com · if URI, then flow.

deck://ifuri/problem

From tangled glue to one address.

Stop scripting integrations. Start routing URIs.

deck://ifuri/idea

Give every process an address you can call.

Functions, scripts, containers, HTTP services, MQTT topics, firmware commands — each becomes a stable, validated URI.

device://device-01/led/set/on
media://local/video/transcode
dns://host/records/command/plan

deck://urirun/anatomy

Anatomy of a URI.

deck://urirun/core-model

One path. Nothing about your tools.

scheme → package·target → instance·segments → operation·payload → data

deck://ifuri/two-ways

Two ways to use it.

for operators

ifuri App

A desktop workspace: visual flow editor, voice UI, chat with endpoints, device and LAN views, and a local HTTP API.

for execution

urirun

A lightweight runtime: scan a project, generate a validated registry, and run URIs from the CLI, a backend, or the app.

deck://urirun/run

Scan. Validate. Run.

# turn project artifacts into a validated registry
urirun scan ./project --registry-out generated/registry.json
urirun validate generated/bindings.v2.json

# dry-run by default — the exact command is printed first
urirun run 'cli://local/git/status' generated/registry.json
urirun run 'media://local/video/transcode' registry.json \
  --payload '{"input":"a.mp4","width":1280}' --execute

Nothing runs until you pass --execute, and every call passes the policy gate.

deck://urirun/mcp-a2a

Your registry is an agent surface.

Any process as an MCP/A2A service — one schema, many surfaces.

deck://ifuri/connectors

A growing connector ecosystem.

deck://ifuri/mesh

Two machines, one call protocol.

deck://ifuri/flows

One flow, five schemes.

flow:
  id: local-review-and-share
do:
  - urirun://local/registry/query/health
  - mcp://filesystem/list:
      path: ./project
  - llm://local/qwen/analyze:
      input: file://project-summary
  - tool://local/report/command/render:
      format: html
  - ifuri://node.lan/services/browser/open:
      url: https://ifuri.com

deck://ifuri/is-isnt

What ifuri is — and isn't.

it is

A naming + contract layer between transport and runtime
A stable, transport-agnostic URI for any process
One validated registry (JSON Schema) → MCP / A2A
Policy and audit on every call
Language-agnostic and local-first

it isn't

A new wire protocol or transport
A replacement for REST / gRPC / MCP / HTTP
A DNS / kube-dns replacement
An API framework — or "just discovering APIs"
Infinite codegen — it's a bounded contract

deck://ifuri/not-this

"Isn't this just…?"

… just an API?

REST, gRPC and MCP define the transport — how to call a service. ifuri defines the address: the same URI runs in-process, over HTTP, gRPC, MCP, shell or MQTT. And not everything is an HTTP API — scripts, containers, devices, MQTT topics, firmware. ifuri addresses them all the same way.

… just DNS / kube-dns?

DNS resolves where a service is — name → host:port. ifuri resolves what you can call, with which contract, and how it runs — with policy and audit. A layer above, and it works outside k8s too: laptops, devices, firmware, LAN peers.

deck://ifuri/install

Run a node in one line.

# local urirun node (Linux / macOS)
curl -fsSL https://get.ifuri.com/node.sh | bash

# the runtime, straight from GitHub
pip install "git+https://github.com/if-uri/urirun.git@main#subdirectory=adapters/python"

# the desktop app
ifuri-app voice --auto-port

deck://ifuri/outro

if URI, then flow.

Give every process an address. Validate it once. Run it from the CLI, a backend, the app, or an agent — local-first, across your LAN.

ifuri.com connect.ifuri.com github.com/if-uri/urirun get.ifuri.com