Core capabilities

Facets covers the full lifecycle of running software on the cloud. You build the infrastructure, provision environments from it, ship changes to them safely, and operate what is running, all from one declarative model and, if you want, by asking an AI agent. Each capability below links to where you configure and use it.

Build infrastructure

Someone has to write the Terraform by hand and then keep it maintained, and over time it drifts from what is actually running. With Facets you describe what your application needs, a database, a cache, a service, and Facets builds the cloud infrastructure for it. You never write or maintain Terraform by hand.

You declare each dependency as an intent and pick a flavor that implements it, so "a database" resolves to a specific, approved implementation. Your whole architecture lives in a single blueprint, versioned in Git as the source of truth for every environment, and the same blueprint runs on AWS, GCP, and Azure. The building blocks are reusable across projects and teams instead of being rewritten each time.

Blueprints and resources →

Provision environments

Environments built by hand drift apart over time, and standing up a new one for a branch, a demo, or a new region can take days. With Facets you just say what kind of environment you want, and it is provisioned in minutes, a full environment from a blueprint, and you can run as many as you need.

This is genuine self-service for developers and DevOps alike: provisioning an environment does not depend on a ticket to another team. It is governed by permissions instead, so each user can provision the environment types they have access to, and nothing more.

Development, staging, and production all come from the same blueprint, so they stay consistent instead of drifting apart. Where an environment genuinely needs to differ, you apply the difference as an override rather than forking the blueprint. Provision a new environment when you need one, and tear it down when you are done.

Environments →

Ship changes

A deploy is often an all-or-nothing push, and when one breaks, rolling back is manual and slow. Facets ships every change as a release: a single, unified pipeline that gathers all the pending changes for the infrastructure block you intend to deploy and takes them out together, so you control how and when they land.

This makes shipping self-service too. You say what you want to ship, and Facets works out and applies every related change for that block in the right order, without breaking anything. Roll a change out gradually with a canary, or across resources in parallel, instead of one all-or-nothing apply. Gate a release behind approvals and guardrail policies, so only changes that meet your rules reach production. When something looks wrong, return to a previous release in one click.

Releases →

Operate and observe

Day-two operations usually mean stitching together separate tools for monitoring, cost, and actions, none of them tied to your infrastructure. Facets builds them into the same place you deploy from, tied to the resources you already defined.

Monitoring, Kubernetes events, and uptime dashboards come with the platform, with no separate stack to build. You see what a service costs alongside how it is running, in one place. And you can act on a live resource, restart it or scale it, without leaving the console.

Operate →

Do it all with AI

Infrastructure work is manual and multi-step, and it is scattered across separate tools and context. With Facets, everything above you can also do by asking. Praxis, Facets' AI agentic platform, carries out the same infrastructure work as a person, everywhere in Facets: design a blueprint, build a module, run a release, or debug a running resource.

Plenty of teams try to stand up their own agent on an open-source framework. Praxis is built for this job in ways a generic or do-it-yourself agent is not:

• It already knows Facets. Praxis ships with built-in, versioned skills for blueprints, modules, releases, imports, and cloud and Kubernetes operations. A custom agent starts from zero, and you maintain that platform knowledge as the platform changes.
• It acts as you, within your permissions. Praxis works through Facets' own Control Plane and Terraform modules under your identity, so it can change only what you are already allowed to change, never through a broad god-mode credential.
• It does not leak your credentials. Cloud and platform credentials are encrypted at rest, resolved for a single command, and never written to disk or shown to the model. This is the security plumbing homegrown agents usually get wrong.
• It is read-only by default and sandboxed. Praxis runs server-side in an OS-level sandbox as a non-root user, and cloud and Kubernetes access stays read-only unless a change is explicitly allowed, enforced inside the tools.
• It understands your whole estate. Each session is seeded with a maintained map of your repositories and their cross-repo dependencies, so it reasons about blast radius, something a single-workspace IDE or DIY agent cannot.
• It works everywhere, and every run is accountable. The same agent and context run from the console, the CLI, your CI pipeline, and Slack, and each run is attributable to a real user, recorded with its actions and cost, and gated against your organization's spend limits.

Praxis →