Agentapproval required
explained the p99 drift · plan ready
Open source · self-hosted · Apache-2.0
Strata: Infrastructure that remembers.
Strata is the open-source stack where your source, deployments, traffic, and telemetry share one memory. Five engines, one substrate, zero SaaS — from a laptop to GCP, AWS, or on-prem Kubernetes.
The short answer
Last updatedWhat is Strata?
Strata is an open-source, self-hosted infrastructure platform. Five engines — MonoFS, Guardian, Doctor, LB-Edge, and Agent — run on one storage fabric, so source code, deployments, traffic, telemetry, and assistance keep the same context.
- License
- Apache-2.0
- Runs on
- GCP · AWS · on-prem Kubernetes · Docker · local server
- Interfaces
- OTLP · OCI · Prometheus · Loki · Tempo
- Start with
./scripts/bootstrap.sh up
No hosted tier. No seat pricing. No telemetry leaving your network. See how it compares.
The wager
Tool sprawl is a memory problem.
Every system you add keeps its own copy of the truth. The repository does not know what shipped. The deployment does not know what it broke. The alert does not know what changed. You become the integration layer.
Strata removes the seams. Source, desired state, traffic, and telemetry live on one fabric, so every question can be answered next to the change that caused it.
See what that buys youThe hidden invoice
- 06 dashboards to reconcile
- 04 stores with different truth
- 03 places an incident can hide
- 01 team holding the seams together
0
copies of the truth
when the fabric is shared
when the fabric is shared
The stack
Five engines.
One memory.
Read it top-down: the top is what you feel. The base is what makes it possible. Each engine owns a hard problem; the fabric is what makes them one system.
-
01Assist
Agent
Otto & SteveAsk the platform. Approve the change.
Agent is a platform-aware assistant with live Guardian, Doctor, MonoFS, and LB-Edge tools. It answers from evidence instead of guessing, plans the next change, and keeps every mutation behind an approval gate.
- Provider presets
- View-aware Ask Strata
- Graph validation
- Steve diff handoff
- Approval gates
-
02Traffic
LB-Edge
L4Routes that follow reality.
LB-Edge is a small L4 registry and TCP proxy that follows Kubernetes Endpoints instead of hand-maintained config. Services register themselves through Guardian intent annotations; draining and failover happen without a reload.
- Dynamic gRPC registry
- Kubernetes Endpoints agent
- Passive circuit breaker
- PROXY protocol
- No database
-
03Observe
Doctor
TelemetryEvery signal. One story.
Doctor is a privacy-first OpenTelemetry backend that stores traces, logs, and metrics together. A SQL console, dashboard bundles, firing alerts, Guardian deployment context, and Grafana-compatible APIs sit on the same query surface.
- OTLP gRPC + HTTP
- HMAC tokenization
- SQL console
- Prometheus · Loki · Tempo
- Pluggable span store
-
04Deploy
Guardian
Control planeDeclare it. Guardian lands it.
Guardian is an intent-based control plane that compiles desired state into a dependency graph, detects drift, and applies the delta across GCP, AWS, on-prem Kubernetes, Docker, or a local server. Synthetic journeys and OTLP histograms make the rollout observable.
- Partitions, intents, assets
- Keeps production in sync
- GCP · AWS · on-prem K8s
- Docker · local server
- Probe journeys
- Full audit trail
-
05Store
MonoFS
The fabricOne workspace. Every repo. All the bytes.
MonoFS is a distributed filesystem that mounts thousands of independent repositories as one writable virtual monorepo. The same durable substrate holds the platform's source, OCI images, desired state, and telemetry chunks — with search, encryption, and replication built in.
- FUSE writable overlay
- Explicit session commit
- OCI registry + code search
- HRW-sharded + encrypted
- Logengine + span store
How it flows
From commit
to clarity.
One loop, six moves. This is the path a change takes through Strata — and the evidence it leaves behind. Select a step to follow it.
Step 01 · Write
Mount only what you need. Publish explicitly.
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-client --mount=/work \
--router=monofs:9090 \
--virtual-monorepo --writable
monofs-session diff
monofs-session commit -m "feat: ship the dashboard"Leaves behind a signed commit, a workspace bundle, and a search index update.
Step 02 · Plan
Desired state becomes a dependency graph.
Guardian compiles the graph, shows the drift, checks that the change is safe, then applies it in the right order. Destroys run in reverse.
apiVersion: guardian/v1alpha1
kind: Partition
metadata:
name: production
spec:
intents:
- name: database
targetPusher: k8s-prod
- name: api-server
joins: [database]
guardianctl partition reconcile --partition productionLeaves behind a checked plan, a deployment revision, and an archive entry.
Step 03 · Route
Traffic follows the deployment, not a config file.
LB-Edge watches Kubernetes Endpoints. Guardian annotations register new backends and pin external ports; removed backends drain until their connections reach zero.
metadata:
annotations:
guardian.intent/expose: "true"
guardian.intent/service-name: "api-server"
guardian.intent/external-port: "8090"
# the proxy reconciles listeners every 2s
curl http://lb-edge:18081/servicesLeaves behind an external port, a live listener, and a registry snapshot.
Step 04 · Observe
Telemetry arrives with deployment context.
Traces, logs, and metrics land in Doctor alongside the Guardian event that produced them. Privacy happens before persistence, and one SQL console spans all three signals.
export OTEL_EXPORTER_OTLP_ENDPOINT=http://doctor:4317
export OTEL_SERVICE_NAME=api-server
curl "http://doctor:18080/v1/guardian/health?partition=production"
# logs, metrics, and traces share one SQL surface
curl -X POST http://doctor:18080/v1/sql/query \
-d '{"tenant":"default","query":"SELECT service, count(*) FROM logs GROUP BY 1"}'Leaves behind a trace, a rollout health window, and a queryable evidence trail.
Step 05 · Ask
Ask the platform, then approve the change.
Agent answers from live Guardian, Doctor, MonoFS, and LB-Edge evidence. It plans the next change and keeps mutations behind an approval gate; Steve can produce a reviewable diff without committing.
cd agent && docker compose up -d
# UI :3000 · API :8090
curl -s http://localhost:8090/api/chat \
-H "content-type: application/json" \
-d '{"message":"why did production drift?"}'
# answers cite live state; mutations need confirm=trueLeaves behind a session, tool-call evidence, and an approval record when you act.
Step 06 · Watch
Nightwatch takes the first pass.
Alerts arrive, Nightwatch correlates them with deploys and telemetry, and hands over a readable incident with evidence, confidence, and an escalation when it cannot be sure. Shadow mode by default.
metadata:
labels:
nightwatch.strata.io/enabled: "true"
# watch, investigate, hand off — never mutate
curl http://agent:8091/v1/incidents?status=openLeaves behind an incident ledger, an evidence pack, and a handoff recommendation.
Nightwatch
The first line.
With receipts.
Nightwatch is a shadow-mode SRE inside Agent. Turn on one partition label and it watches alerts, investigates with Doctor, and hands you the incident with the evidence already attached. Shadow mode by default — it never gets the keys.
- Read-only. No Guardian, Doctor, or Sentinel mutation calls.
- Evidence first. Every finding preserves the query, time range, result hash, and source.
- Honest uncertainty. Low confidence becomes an escalation, not a guess.
- Handoff, not heroics. Cross-partition causes go to the owning team.
NW-0412
warning
03:17 UTC
PusherHeartbeatStaleproduction / payments
investigating
Evidence pack
- guardiandeploy r-8841
- doctortrace 9f3c…
- metricsup{service="payments"}
- topologyorders → payments
Root-cause candidate: payments82%
Recommendation
Roll back r-8841 or restart the payments pusher. Handoff to payments-oncall if the next window is still red.
0x8f2c… · illustrative interfaceFresh off main
Latest changes
in Strata.
The platform moved fast since this page last shipped. Here are the November release notes, with the engine that owns each change.
-
Guardian
Native on GCP, AWS, and on-prem Kubernetes.
Guardian now targets GCP with a first-class OpenTofu pusher, alongside its existing AWS and on-prem Kubernetes pushers. The same partitions, intents, and assets apply; only the pusher and credentials change. Docker and local server targets stay for development.
-
MonoFS · Doctor
The span store is now a choice.
Logs, metrics, and traces can move to a pluggable span store. The local default remains available, and the Doctor and Grafana APIs do not change. Partition-aware chunks, scatter-gather aggregation, query budgets, and retention are in.
-
Doctor
SQL over every signal.
The SQL console runs against
logs,metrics, andtraceswith identity-scoped caching, partition scope, row and byte caps, and one query API. Dashboard graph bundles and a tabbed chart UI make the same data easier to read. -
Guardian
Deployments that measure themselves.
Pusher task duration is exported as OTLP exponential histograms. Synthetic user journeys render as first-class probe assets, and AWS observed state now includes CloudWatch alarm history.
-
Agent
The assistant got sharper tools.
LLM provider presets, a graph validation skill, view-aware Ask Strata, and LB-Edge tools. Otto can answer questions from the traffic plane as well as Guardian, Doctor, and MonoFS.
-
Agent · Nightwatch
Nightwatch hands work to Steve.
Incidents now produce deterministic and LLM improvement proposals. Hand one to Steve and he opens a reviewable diff through the MonoFS workspace — no commit, no push, no surprise.
-
Guardian · LB-Edge
The platform has platform partitions.
Nightwatch, Prometheus edge wiring, and platform partitions are packaged with the rest of the stack. Probe assets now cover multi-step user journeys, not just single checks.
The full history lives in the repositories. This page is static; the source of truth is the code.
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"yaml partitions/production.yaml
apiVersion: guardian/v1alpha1
kind: Partition
metadata:
name: production
spec:
intents:
- name: database
targetPusher: k8s-prod
- name: api-server
targetPusher: k8s-prod
joins: [database]
# drift is computed before anything is applied
guardianctl partition reconcile --partition productionshell point telemetry at Doctor
export OTEL_EXPORTER_OTLP_ENDPOINT=http://doctor:4317
export OTEL_SERVICE_NAME=api-server
# traces, logs, and metrics share one store
curl "http://doctor:18080/v1/traces/<traceID>"
# one SQL surface for every signal
curl -X POST http://doctor:18080/v1/sql/query \
-H "content-type: application/json" \
-d '{"tenant":"default","query":"SELECT service, count(*) FROM logs GROUP BY 1"}'yaml let the service announce itself
metadata:
annotations:
guardian.intent/expose: "true"
guardian.intent/service-name: "api-server"
guardian.intent/external-port: "8090"
# the proxy syncs Endpoints; no reload, no static route file
curl http://lb-edge:18081/servicesshell ask the platform
cd agent && docker compose up -d
# UI :3000 · API :8090
curl -s http://localhost:8090/api/chat \
-H "content-type: application/json" \
-d '{"message":"why did production drift?"}'
# answers cite live state; mutations stay behind approval
one fabricstandard protocolsno lock-in
Why Strata
Fewer seams.
Better answers.
Strata is not a hosted product wearing an open-source badge. It is the operating model of a platform team, written down and made runnable.
Layer
Typical stack
With Strata
Source
Git + partial clone + separate artifact store
MonoFS — one virtual monorepo, OCI registry, and search on the same fabric
Deploy
Helm + Argo + scripts with ordering in your head
Guardian — typed intents and a dependency graph. That's it: Guardian owns the rollout and keeps production in sync.
Traffic
Hand-maintained LB config and stale routes
LB-Edge — a registry that follows Kubernetes Endpoints and drains safely
Telemetry
Prometheus + Loki + Tempo + a bucket, stitched together
Doctor — OTLP in, privacy first, one query surface, Grafana-compatible
Assistance
A generic chat tab that cannot see your platform
Agent — live tool calls, approval gates, and a shadow SRE with evidence
Truth
Five copies, reconciled by a person at 03:00
Strata — one fabric, one audit trail, one place to look
No hosted tier. No seat pricing. No data leaving your network.
Apache-2.0, top to bottom. Run it on a laptop, a kind cluster, on-prem Kubernetes, GCP, or AWS. Read the code that runs your platform, fork it when you disagree, and keep the operating model.
The alert arrives with the deploy attached.
Guardian events land in Doctor. Nightwatch correlates alerts with traces, topology, and recent changes before it hands over an incident.
Check before apply.
Drift is detected, changes are validated, and every write carries a principal, reason, and correlation ID.
Tokenize before you store.
Doctor anonymizes sensitive fields with deterministic HMAC tokenization, per tenant, before persistence.
Bring your own everything.
OTLP collectors, Grafana dashboards, OCI images, S3 or GCS upstreams, and a pluggable span store. Strata fits the stack you have.
Self-hosted on GCP, AWS, or your own metal.
Native pushers for GCP, AWS, and on-prem Kubernetes, plus Docker and a local server for development. Same intent model, same telemetry surface, same audit trail — wherever the work lands.
The honest fine print. Strata is not a managed service. You own upgrades, capacity, and the 03:00 pager. That is the trade for owning the whole stack — and the reason it can stay small.
Run it before you believe it
Thirty seconds
to first light.
Clone the umbrella repository and bootstrap a local kind cluster. No account, no trial key, no sales call.
git clone https://github.com/radryc/strata.git
cd strata
./scripts/bootstrap.sh upAlready have a cluster? ./scripts/bootstrap.sh k8s --build --push · AWS? ./scripts/bootstrap.sh aws --with-pusher -y
Questions, answered
The things
people ask first.
Short answers with links to the code. If something is missing, open an issue — the repository is the source of truth.
What is Strata?
Strata is an open-source, self-hosted infrastructure platform made of five engines: MonoFS for source and storage, Guardian for deployment, Doctor for observability, LB-Edge for traffic, and Agent for assistance. They share one storage fabric, so source, desired state, telemetry, and deployment context stay connected.
What are the five engines in Strata?
MonoFS is the source and storage fabric. Guardian is the deployment control plane. Doctor is the observability plane. LB-Edge is the traffic plane. Agent is the assistance plane. Nightwatch is a shadow-mode capability inside Agent, not a sixth engine.
Does Strata replace Prometheus and Grafana?
Strata replaces the storage and query layer, not the interfaces. Doctor accepts OTLP and exposes Prometheus, Loki, and Tempo APIs, so existing Grafana dashboards and collectors can keep working. You can also keep Prometheus for workloads that need it.
Is Strata free and open source?
Yes. Strata is licensed under the Apache License 2.0. There is no hosted tier, seat pricing, or usage meter. You can read, run, modify, and self-host the code.
Who maintains Strata?
Strata is built and maintained in public by @radryc, with contributions from the open-source community. The code, issues, and release history live on GitHub.
Is there a hosted version of Strata?
No. Strata is self-hosted software: you run it on your own laptop, cluster, or cloud account. That keeps the data, credentials, and operating model under your control. The trade-off is that you own upgrades and capacity planning.
What does Strata replace?
Strata replaces the glue between a Git host, artifact registry, deployment pipeline, load balancer, observability stack, and AI assistant. It does not require you to abandon standard protocols: OTLP, OCI, Prometheus, Loki, Tempo, and Kubernetes Endpoints are supported.
How do I install Strata?
Clone the public umbrella repository and run the bootstrap script. With Docker, kind, kubectl, Go 1.26+, and OpenSSL installed:
git clone https://github.com/radryc/strata.git
cd strata
./scripts/bootstrap.sh upDoes Strata work with GCP, AWS, and on-prem Kubernetes?
Yes. Guardian ships native pushers for GCP, AWS, Kubernetes (including on-prem), Docker, and a local server. The same partitions, intents, and assets apply; only the pusher and credentials change. The bootstrap script supports a local kind cluster, an existing Kubernetes cluster, and AWS; GCP uses guardianctl gcp setup to verify prerequisites and prepare the native pusher.
How does Strata keep telemetry private?
Doctor anonymizes telemetry before persistence. Secret-looking keys and values are redacted, identity-like fields are replaced with deterministic HMAC tokens, and emails and IPv4 addresses in free text are tokenized before records reach the write-ahead log or storage.
What is Nightwatch?
Nightwatch is a shadow-mode SRE capability inside Agent. It watches alerts, investigates with Doctor and Guardian evidence, records incidents, and recommends a handoff or escalation. It is read-only by default and does not mutate infrastructure or acknowledge alerts.
Is Strata production-ready?
The core engines run in production-style GCP, AWS, and on-prem Kubernetes deployments, and the project is developed in public. It is not a managed service: you own the operating model, upgrades, and capacity planning. The repository documents known gaps, failure modes, and bootstrap paths.
Still curious? Read the umbrella repository or browse every engine.
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.
github.com/radryc/strata · Apache-2.0 · open source