// THREAT ASSESSMENT

THE PROBLEM

Even the best helmsmen can't navigate these waters alone.

CRITICAL
CURRENT OPERATIONAL STACK
  • GitHub Actions / CircleCI
  • Docker / Nix
  • Kubernetes / Nomad
  • Helm / Kustomize
  • ArgoCD / Flux
  • Prometheus / Datadog
  • Grafana
  • PagerDuty / Opsgenie
  • Jaeger / Honeycomb
  • Terraform / Crossplane / AWS CDK
  • IAM / Vault
12+ TOOLS // 12+ CONFIG FORMATS // 12+ FAILURE MODES
NOMINAL
ULMO OPERATIONAL STACK
ULMO [ EVERYTHING ]
let api = Service::builder("api") .replicas(3) .connect("db") .connect("cache") .build(); let topo = Topology::builder() .add_service(api) .add_store(Store::postgres("db")) .add_store(Store::redis("cache")) .build()?;
ONE TOPOLOGY // ONE COMPILER // ONE SOURCE OF TRUTH

// TACTICAL READOUT

INFRASTRUCTURE, BY [co] DESIGN

Define your system. The topology compiler handles the rest.

[ TOPOLOGY YOU CAN TEST ]
The topology is a value you can hold. Write tests against it.

Does the system survive an AZ failure? Is blast radius bounded? cargo test for your infrastructure.
#[test] fn system_properties() { let topo = build_topology(); assert!(topo.survives_az_failure()); assert!(topo.blast_radius("db") < 3); assert!(topo.all_public_have_auth()); }
[ AUDITABLE INFRASTRUCTURE ]
Understanding what's running shouldn't require intervention by Indiana Jones.

Drift detection is automatic. The compiled topology is the source of truth — compliance is guaranteed, correctness is verifiable.
topo.blast_radius("orders-db") // → what breaks if this dies? topo.transitive_deps("api-gateway") // → what does this need? topo.public_services() // → what's exposed?
[ AGENT-READY OPERATIONS ]
AI agents will enable teams to deploy and operate code at unprecedented scale.

They need legible representation, verifiable properties, bounded blast radius, and safe rollback. The topology compiler produces exactly this.
let output = compiler.compile(&topo)?; let diff = output.diff(&live)?; // typed IR → agents can reason // about changes before applying diff.apply().await?;

// LIVE DEMONSTRATION

THE INTERFACE

Three ways in. Same topology. CLI, web, or TUI.

ULMO TERMINAL
ULMO DASHBOARD
SERVICES
NAME
VERSION
REPLICAS
STATUS
api
v1.2.0
3/3
healthy
worker
v1.1.8
5/5
healthy
relay
v0.9.3
7/7
healthy
REQUESTS/s 1,247
P99 LATENCY 12ms
ERROR RATE 0.02%
UPTIME 99.97%
ULMO TUI
ULMO // SERVICES
3 SERVICES // 7 NODES
api HEALTHY
worker HEALTHY
relay HEALTHY
[ SERVICE: API ]
VERSION
v1.2.0
REPLICAS
3/3
CHANNEL
stable
UPTIME
14d 7h 23m
CPU
23%
MEMORY
1.2GB / 4GB
RECENT LOGS
13:04:02 INFO handling request user_id=u_8f2a
13:04:02 INFO query completed duration=7ms
13:04:02 INFO response sent status=200
j/k navigate
enter select
l logs
d deploy
r rollback
q quit

// THE SDK

TOPOLOGY COMPILER

You define the topology. Resources are a compilation target.

[ src/main.rs ]
// Define the system. The compiler handles the rest. use ulmo::prelude::*; let relay = Service::builder("edge-relay") .replicas(5) .identity(Identity::Stable) .peers(true) .data(Data::Ephemeral) .port("default") .port("raft") .connect("verification-sink") .source(SourceBinding::github("co", "edge-relay")) .build(); let sink = Service::builder("verification-sink") .port("default") .connect("relay") .build(); let topo = Topology::builder() .add_service(relay) .add_service(sink) .add_store(Store::postgres("events-db").build()) .build()?; // Compile to infrastructure let output = Compiler::new().compile(&topo)?;
CODESIGN Service + infrastructure in one definition. The topology is part of the source.
COMPILE-TIME Invalid topologies don't build. Constraints verified before anything touches a cluster.
AUDITABLE Blast radius, dependencies, public surface -- ask questions of the graph.
ZERO GLUE No YAML. No Helm charts. Resources are a compilation target, not a concern.

TYPED CODE. NOT CONFIG FILES.

// TACTICAL SCHEMATIC

ARCHITECTURE

The intelligence is in the compiler. Backends are replaceable.

LAYER 01 // INTERFACE
CLI / GUI
ulmo CLI Web Dashboard Config Editor
LAYER 02 // CONTROL PLANE
ULMO CORE
API Build System (Nix) Scheduler Release Manager Observability Config Mgmt
LAYER 03 // RUNTIME
FLEET MANAGEMENT
us-east-1a us-east-1b us-west-2a eu-west-1a

// ABOUT US

THE PRODUCTION SOFTWARE COMPANY

Software is on the critical path of everything. Your money, your health records, your transit, your communication — you can't opt out -- none of us can.

And it's broken. Routinely. Incidents are accepted as inevitable. "AWS is down" is a meme, not a crisis. We've collectively lowered our expectations to match what the industry delivers.

This isn't because people got dumber. It's because complexity outpaced tooling. The systems are too big for anyone to hold in their head. "Move fast and break things" won, and now we're stuck with the broken things.

And it's about to get worse.

AI is generating code faster than humans can review it. The same teams that are drowning with tens of services will soon have hundreds. More deployments, more complexity, more surface area — same tools, same processes, same 3am pages.

The Production Software Company was founded by folks who've grown irate with the quality and reliability of software that has found its way onto the critical path of our daily lives.

We're not pessimists about software. The opposite — we've built and operated software for some of the world's most critical institutions, and we're big believers in the good it can do. Software should make healthcare more accessible, infrastructure more resilient, daily life less frustrating. It can. Sometimes it does.

Sometimes isn't good enough.

Ulmo is our first product: infrastructure you can understand, test, and trust. But the mission is broader. Production software should be as reliable as the things it replaced. We're building tools for people who take that responsibility seriously.

// GET STARTED

JOIN THE WAITLIST

Ship faster with fewer incidents. We'll let you know when it's ready.

EARLY ACCESS
Be first to define your infrastructure as a program. Topology compiler, typed SDK, auditable graph.
ULMO // MASTER OF THE DEEP WATERS
THE PLATFORM FOR OPERATING SOFTWARE