Strata · open source, self-hosted

The whole stack.
One surface.

Strata unites MonoFS, Guardian, Doctor, and Agent — open-source engines for your source, deployments, telemetry, and assistance. Apache-2.0, self-hosted, and developed in the open.

Browse the source See how it flows
  • Open source
  • Apache-2.0
  • Self-hosted
  • K8s · Docker · AWS

The platform

Four engines.
One source of truth.

Most platforms are a pile of tools with a shared login. Strata is built on a shared substrate — the same files, state, and telemetry underneath every layer. The whole stack is open source and runs on your own hardware.

Deploy Guardian intent → diff → apply
Observe Doctor traces · logs · metrics
Assist Agent ask · plan · approve
MonoFS storage fabric
sourceimagesdesired statetelemetry
01

One fabric, not four silos

Source, artifacts, deployment state, and telemetry share one durable substrate. No copy jobs, no sync drift.

02

Deployment context everywhere

Every trace and metric can be read next to the rollout that produced it. “What changed?” stops being a hunt.

03

Open primitives, no trapdoor

FUSE, OTLP, OCI, Prometheus, Loki, and Zipkin. Strata connects the standards you already run.

04

Safe by construction

Desired state is diffed and checked before it is applied. Drift is visible, mutations are attributable.

The stack

Hard problems.
One fabric.

Each engine owns a hard problem. The magic is what happens when they share the same fabric.

01 / Store

MonoFS

One workspace. Every repo.

Mount thousands of independent repositories as one writable virtual monorepo. Edit locally, publish explicitly, and keep the whole platform's bytes in one place.

  • FUSE mount with a writable overlay
  • Explicit monofs-session commit
  • OCI registry, code search, and log engine on the same fabric
  • HRW-sharded, replicated, encrypted at rest
02 / Ship

Guardian

Declare it. Guardian lands it.

An intent-based control plane that compiles desired state into a dependency graph, detects drift, and applies the delta across Kubernetes, Docker, AWS, or local targets.

  • Partitions, intents, and assets — not shell scripts
  • DIFF → CHECK → APPLY with automatic ordering
  • Pluggable pushers for K8s, Docker, AWS, local
  • Locked state, output interpolation, full audit trail
03 / See

Doctor

Every signal. One story.

A privacy-first OpenTelemetry backend that stores traces, logs, and metrics together — then adds Guardian deployment context and Grafana-compatible APIs.

  • OTLP gRPC and HTTP ingest
  • HMAC tokenization before persistence
  • Guardian health and topology APIs
  • Prometheus, Loki, and Zipkin out of the box
04 / Assist

Agent

Ask the platform. Approve the change.

An assistant with live Guardian, Doctor, and MonoFS tools. It answers from evidence instead of guessing, plans the next change, and keeps every mutation behind an approval gate.

  • Otto for SRE work, Steve for code
  • Live tool calls over Guardian, Doctor, MonoFS
  • Approval-gated deploys and workspace edits
  • Local model, external API, or OpenCode

How it flows

From commit
to clarity.

One loop. No hand-offs between tools. This is the path a change takes through Strata.

  1. 01
    Write

    Mount only what you need

    A developer opens a virtual monorepo, edits in a local overlay, and publishes one explicit commit. No giant clone, no waiting for an indexer.

    MonoFS
  2. 02
    Reconcile

    Desired state becomes a plan

    Guardian compiles the dependency graph, shows the drift, checks that the change is safe, then applies it in the right order.

    Guardian
  3. 03
    Observe

    Telemetry arrives with context

    Traces, logs, and metrics land in Doctor alongside the deployment event that produced them. The rollout is part of the trace.

    Doctor
  4. 04
    Ask

    Ask the platform, then act

    Agent answers from live Guardian, Doctor, and MonoFS evidence, plans the next change, and keeps mutations behind approval.

    Agent
And the loop keeps closing.

The primitives

Keep the
real thing.

Strata is a surface, not a proprietary layer. Underneath are filesystems, manifests, and standard protocols you can inspect, script, and take with you.

  • No proprietary deployment DSL
  • No telemetry format you have to adopt
  • No data plane you cannot see into

The snippets are the actual interfaces. Swap the hostnames for yours.

shell mount a workspace
monofs-client --mount=/dev/monorepo \
  --router=monofs:9090 \
  --virtual-monorepo --writable

# work normally — git, IDEs, tests
cd /dev/monorepo && git status

# publish explicitly
monofs-session diff
monofs-session commit -m "feat: ship the dashboard"
one fabricstandard protocolsno lock-in

Why Strata

Fewer seams.
Better answers.

One fabric

Your source, images, state, and telemetry stop living in different worlds.

MonoFS is the substrate under Guardian, Doctor, and Agent. That means fewer copies, fewer credentials, and one place to reason about durability.

Deployment-aware

See the rollout inside the trace.

Doctor ingests Guardian events directly. Error spikes and deploy timelines sit in the same window.

Safe by default

Check before apply.

Drift is detected, changes are validated, and every write carries a principal, reason, and correlation ID.

Privacy first

Tokenize before you store.

Doctor anonymizes sensitive fields with deterministic HMAC tokenization, per tenant, before persistence.

Open interfaces

Bring your own everything.

OTLP collectors, Grafana dashboards, OCI images, S3 or GCS upstreams. Strata fits the stack you have.

Runs where you do

Self-hosted from laptop to production.

Kubernetes, Docker, AWS, or a single local process. Same intent model, same telemetry surface, same audit trail — wherever the work lands.

Open source

Read the code.
Run it yourself.

No sales call and no waiting list. Clone the repos, run the stack, and open an issue when something breaks. Issues and PRs are welcome.

Browse on GitHub Read the primitives

github.com/radryc/strata · Apache-2.0 · open source