about.ifuri.com

ifURI,
then flow.

One local-first runtime that turns every command, service, container and app into an addressable URI — then composes them into flows across MCP tools, A2A agents, local LLMs and LAN devices.

$ curl -fsSL https://get.ifuri.com/node.sh | bash
==> urirun node "laptop" ready · 9 URI routes · http://laptop.lan:8765/
$ urirun run 'browser://pc1/page/command/open' registry.json --execute
{ "ok": true, "uri": "browser://pc1/page/command/open", "status": 200 }
$ 

ifURI vs urirun

Two names, one idea.

In short: urirun is the runtime you embed; ifURI is what you run, install and use.

The problem

Every integration is a one-off.

Shell scripts, HTTP calls, Docker commands, MCP servers, agents and device APIs each speak a different language. Glue code rots, nothing is reusable, and nothing is auditable. You can't address a capability — you can only re-implement calling it.

The idea

Name it once. Run it anywhere.

Declare an action one time as a stable address — scheme://target/resource/operation — and call it from a shell, backend, frontend, flow or agent. urirun validates the payload against a schema, gates it with policy, and dispatches it.

flow:
  do:
    - urirun://local/registry/query/health
    - mcp://filesystem/list: { path: ./project }
    - llm://local/qwen/analyze: { input: file://project-summary }
    - ifuri://office-node.lan/services/browser/open: { url: https://ifuri.com }

One runtime

Flows, MCP, A2A, LLM and LAN — one contract.

Connectors

Capabilities as installable packages — in any language.

A connector declares URI routes once and exports a registry. The runtime is a contract, not a language: a connector's executable can be written in anything, and the urirun SDK ships for multiple languages so it can be a library inside your project.

Generate connectors from a command, a service, or an artifact like a Docker image — the same urirun.bindings.v2 contract every time. Browse the public hub at connect.ifuri.com.

One contract, any language

The same connector — Python, JS, PHP.

A connector just emits a urirun.bindings.v2 document. The SDK ships per language, so urirun is a library inside your project. Each snippet below produces the identical contract — urirun validate accepts all of them.

c = urirun.connector(
  "hash", scheme="hash")

@c.command("sha256/command/file")
def f(path: str):
  return ["sha256sum", "{path}"]

connector("hash",{scheme:"hash"})
  .command("sha256/command/file",{
    input:{required:["path"]},
    argv:["sha256sum","{path}"],
  })

(new Urirun\Connector("hash","hash"))
  ->command("sha256/command/file",
    ["required"=>["path"]],
    ["sha256sum","{path}"]);

Local-first & auditable

It runs on your laptop, one command.

curl -fsSL https://get.ifuri.com/node.sh | bash -s -- --name laptop --connectors http-check,time-tools

Every call carries an envelope: URI, payload, decision, status, time and source. Nothing runs by accident — execution is default-deny behind an explicit policy gate.

The ecosystem

Sites, runtime, connectors, demos.