the problem

Everyone can build with agents now.
Almost nobody can ship it.

the idea

One governed path from idea to a shared URL.

Fleetworks

One control plane for six moving parts.

scroll
why this exists

Great idea. No way to ship it.

Everyone has agents now. Agents that can write a working app in an afternoon. What almost nobody has is a governed way to get that app in front of the rest of the company: a real URL, real access control, a real audit trail, without filing a ticket and waiting two weeks.

That governed path already exists, and five apps built it. Register a service in Yellow Pages, and its DNS in Chorus, its deployment in Helmsman, its cloud accounts in Warden, and its owning team in Rolodex all resolve back to the same source of truth. Same unix-style owner, group, other permissions everywhere. Same audit trail everywhere.

Two things are true at once. DevOps teams would run the Fleetworks suite for that governed path today. And that same architecture will let any employee do the same: describe an idea, click one button, get back a working, governed, shareable URL. No ticket. This isn't a roadmap slide, it's what the core already does.

the suite

Five real apps, running today.

Not a concept deck. Every screenshot below is the live product.

Yellow Pages agent catalog, showing agents with owners, kinds, and runtimes
Yellow Pages

The catalog everything else points to.

Ask it one question, get the whole picture. A service's deploy state, DNS, workspaces, and owner all resolve back to the same registry.

  • Semantic Operational Graph unifies vocabulary across all five apps
  • Bidirectional connectors write back to real systems, not just read them
  • Catalog Auditor flags RBAC gaps before they become incidents
Open Yellow Pages
Rolodex directory listing users synced from the company directory
Rolodex

Know who to page.

It doesn't just mirror your directory. Rolodex reconciles who has access to what across GitHub, Azure DevOps, and GitLab, and shows you the drift.

  • Full audit ledger of every access change
  • Native mobile app for on-the-go lookups
  • Signed webhooks keep every other app in sync
Open Rolodex
Chorus DNS dashboard showing record and domain counts
Chorus

DNS you can trust.

A rules engine catches the mistake before you ship it. A bad A record, a leaked private IP, a duplicate name. Guardrails before flourish.

  • Deterministic record linter, not an AI guessing at your DNS
  • Signed, SSRF-pinned webhook delivery
  • Push notifications to the on-call phone when a delivery fails
Open Chorus
Warden workspace list showing Terraform Cloud workspaces by tenant and region
Warden

Infrastructure changes that ask first.

Registered is not applied. Warden tracks every Terraform Cloud workspace across AWS and Azure. It never applies a change on its own, that boundary is the whole point.

  • Scoped API tokens, not blunt roles
  • Cloud account numbers stay out of public view, no matter the permission bits
  • Same RBAC model shared with every other app in the suite
Open Warden
Helmsman agent list showing real AI agent runtimes with permission modes
Helmsman

Where the agents actually run.

Real AI agents, with real guardrails. The Autonomy Ladder lets trusted automation earn fewer approvals over time, and demotes itself the moment it fails.

  • OpenAI and Claude runtimes, governed tool access per agent
  • Approve a deployment from your phone, the moment the gate opens
  • Every agent registers itself back to Yellow Pages automatically
Open Helmsman
the control plane

One button. Any scale.

Helmsman is the control plane for deployments and agentic workloads. Applications, CI/CD pipelines, cluster deployments, and the agents doing the work, all under one org-scoped RBAC and audit model. Built for platform and DevOps teams first, because someone has to be in the know. Built to become one button for any employee's idea, because that's what the architecture underneath it already points toward.

  • Say what you want, get a working pipeline.

    Describe a deployment in plain language and Helmsman scaffolds the application, the CI/CD config, and the agent wiring. No manifest to hand-write.

  • From one person's side project to a fleet across regions.

    The same control plane that ships a one-off site tracks pipelines, runs, and deployments across every cluster, at whatever scale the org actually needs.

  • Agents are a governed resource, not a demo.

    Real OpenAI and Claude runtimes, invoked and routed per agent, every run audited. An autonomy ladder earns fewer approval gates as trust builds, and demotes itself the moment it fails.

  • Every tool an agent touches is registered and scoped.

    A governed MCP tool registry syncs both ways with Yellow Pages, so what an agent can reach is never a mystery, and nothing runs unaccounted for.

The agent is portable. So is the way you govern it.

Where this is heading: right now, AWS governs agents on AWS and Azure governs agents on Azure, and neither crosses the boundary. Helmsman's cross-cloud control plane is extending the same permission model, approval flow, audit trail, and spend cap across both, so one agent definition is governed the same way no matter which cloud runs it. This layer is in progress, built one governed capability at a time, proven before it ships.
Diagram: an agent definition flows into Helmsman as one control plane handling permissions, approvals, audit, tool broker, and spend caps, then out to AWS and Azure, with audit, usage, and results flowing back. One governance model, two clouds.
proof

Built the way you'd want it built.

No fluff. Just what actually happened.

01
Two independent AI code reviews caught two different real bugs in the same identity-migration plan before a single line of code shipped.
02
Every app runs on its own isolated database. A bug in one app cannot leak into another, by design, not by luck.
03
2,269 tests and 349 end-to-end checks run across the suite today.
04
Uptime monitoring hits the real database, not a fake ping that stays green during an outage.
05
A self-hosted review bot already watches every pull request on two live repos: 374 approvals, 311 revisions caught.
architecture

Yellow Pages is the hub. Everything else is a spoke.

Every edge in this system is a loose reference, a stored ID, not a hard database link. Any one app can go down without breaking anyone else's schema. That's not an accident. It's the whole design. Scroll to see it build, piece by piece.

01

Yellow Pages

The catalog of record. Every service, agent, and account gets registered here first, and everything else points back to it.

02

Rolodex

The owning team resolves through Rolodex. Incident? You already know who to page.

03

Chorus

DNS for that same service lives in Chorus, keyed by the same registry ID, never a separate record to lose track of.

04

Warden

Its cloud accounts and Terraform workspaces register in Warden, scoped to the same service, the same owner.

05

Helmsman

Deployments and agents run through Helmsman, and report back to the same catalog entry everything else already agrees on.

step 1 of 5

where this actually stands

Honest about what's shipped and what isn't.

live today

The governance pattern, one RBAC model, one audit trail, already runs in production across all five apps.

rolling out

Mobile parity is shipping app by app: Rolodex, Chorus, Helmsman, and Warden each get a native companion.

direction, not shipped

Cross-cloud agent governance, and a one-button path from any employee's idea to a shared, governed URL, are where this is heading next.

see for yourself

See it running.

Every app below is live. No demo account, no waiting list, just sign in.