omnifs: access the world through your filesystem

/intro

every system already speaks omnifs

/glue

One namespace to access everything.

APIs made systems and platforms programmable, but they did not give us a shared substrate. In fact, they encouraged fragmentation.

Each service exposes its own API, schema, auth model, terminology, error table, pagination rules, rate limits. Often, each requires a dedicated SDK.

Conversely, the filesystem is the most durable interface in computing. Every program, agent, language masters disk and file I/O. Semantics are strict and universally understood, and /filesystem/paths offer hierarchical addressing.

const octokit = new Octokit({ auth })
const { data } = await octokit.rest
  .issues.get({ owner, repo, issue_number })
console.log(data.title)
// + install the sdk
// + implement the auth flow
// + paginate, retry, rate-limit
// + repeat for every other vendor

How does omnifs relate to MCP? MCP gives models tools to call. omnifs gives them API-backed resources as paths. A path can be traversed, grepped, diffed, cached, and piped to any other process.

/paths

Paths are the unified interface.

/omnifs mounts systems, services, data sources (really, anything), onto the local filesystem. Instead of teaching humans, agents, and programs how to deal with every API, they can all rely on the same stable interface we've known and loved for decades: files and directories.

Every provider translates its service into directories, files, fields, rendered views, and searchable trees.

The common layer is not a universal schema. The common layer is the filesystem: paths that humans, scripts, agents, caches, and traces can all operate on without learning the upstream API.

/pipe

Pipe data and state across systems.

Once services share a filesystem substrate, pipes can cross system boundaries. Read a CI run, inspect a container, grep the ticket queue, or sketch new providers for the systems you wish were files.

# provider sketch
$ cat /cloudflare/zones/0xff.ai/firewall/events/latest/client_ip \
    | xargs -I% cat /dns/reverse/%
census-12.shodan.io

/providers

A growing pool of providers.

The provider catalogue is the source of truth for documented provider path surfaces. Providers are the extension point: if a system has an API, socket, repository, database, object store, or control plane, it can have a path.

next up   /huggingface /kubernetes /s3 /slack

provider catalogue ->

/architecture

Providers ask. The host acts.

Capabilities replace ambient authority. Providers answer filesystem requests inside a Wasmtime sandbox, with no ambient network, disk, environment, credentials, or access to other providers.

When a provider needs the outside world, it asks the host for a declared, capability-gated callout. The host enforces reachability, attaches credentials, performs the effect, and resumes the operation.

/sdk

Bring your own system.

The omnifs SDK is how your world enters the filesystem.

Internal APIs, queues, deploys, incidents, databases, model gateways, billing, feature flags, customer state: mount the systems that matter to you, then let tools and agents work through paths.

use omnifs_sdk::{browse::FileContent, prelude::*};

#[omnifs_sdk::object(kind = "github.issue", key = IssueKey)]
#[derive(Clone, Serialize, Deserialize)]
struct Issue { title: String, state: String, body: String }

impl Issue {
    fn title(&self) -> Result<FileContent> { Ok(FileContent::new(self.title.as_bytes())) }
    fn state(&self) -> Result<FileContent> { Ok(FileContent::new(self.state.as_bytes())) }
    fn body(&self)  -> Result<FileContent> { Ok(FileContent::new(self.body.as_bytes())) }
}

#[path_captures]
struct IssueKey { owner: OwnerName, repo: RepoName, filter: Facet<StateFilter>, number: u64 }

impl Key for IssueKey {
    type Object = Issue;
    type State = State;

    async fn load(&self, cx: &Cx<State>, since: Option<Validator>) -> Result<Load<Issue>> {
        load_issue(cx, self, since).await
    }
}

#[omnifs_sdk::provider(
    metadata = "omnifs.provider.json",
    resources(endpoints = [api::GitHubApi], git = true),
)]
impl GithubProvider {
    type Config = Config;
    type State = State;

    fn start(_cfg: Config, r: &mut Router<State>) -> Result<State> {
        r.object::<Issue>("/{owner}/{repo}/issues/{filter}/{number}", |o| {
            o.representations("item", (Markdown,))?;
            o.file("title").project(Issue::title)?;
            o.file("state").project(Issue::state)?;
            o.file("body").lazy().project(Issue::body)?;
            Ok(())
        })?;
        Ok(State::default())
    }
}

/uses

A new paradigm to interact with services.

Files can move, cache, replay, and leave traces. Put remote state behind paths, and those behaviors open up to agents, scripts, notebooks, and people.

/lineage

/roadmap