The platform, one level down.
Fractal Cloud turns infrastructure into versioned, governed components, deploys them on any provider, and lets agents operate them inside the rules attached to them.
Infrastructure built the way software is built.
Software stopped being written from scratch a long time ago: you take proven components and put them together. Infrastructure never got there, every environment is assembled again by hand, in scripts nobody else can reuse. A Fractal is that missing component: a piece of infrastructure you build once, and then use.
Every Fractal is made of two items, and both are versioned together.
What it is made of.
The components, the connections between them and the configuration that together make a valid, compliant system. Versioned as one unit.
What you allow to be done to it.
A versioned set of operations that add, remove or change parts of it. Every operation has to leave behind either a compliant system, or a more specialised Fractal that still fits the model.
A Fractal is a component too. That is the whole idea.
Fractals are components themselves. One can be nested inside another, exactly like any other component, at any scale.
That is what makes security and compliance compound. The controls on the outer Fractal apply to everything inside it, and each inner Fractal adds its own on top. Controls do not get weaker as systems grow.
If you know classes and objects, you already know this.
The model is the one developers use every day, applied to infrastructure.
One more thing follows from it: the same Fractal can be instantiated many times, each time resolving its components to different supported technologies. One definition, several running systems, on whichever provider each of them needs.
Agents build and operate it, inside your limits.
A fleet of specialised agents, one per discipline: onboarding, architecture, security and compliance, day-2 operations, audit evidence. They translate what you ask for into governed systems, then provision, reconcile and operate them on any cloud. Governance and reusability are what make that safe: the agents work on Fractals your teams defined, so the limits are already in the thing they are working on.
It proposes.
The agent works out what to do and shows you. Nothing is applied.
It executes once approved.
One approval, and the agent carries the whole task through.
It is fully automated.
The task runs on its own, within the same rules, and reports what it did.
The level is set per task and changed whenever you want. Beyond it, the agent asks. Every action is attributable and reversible, and the same foundation is open to you: build and run your own agents on the platform through the Fractal Agent API.
Two ways in, nothing thrown away.
You start from the assets you already have. Whichever way a system arrives, it lands in your library and is governed from then on.
Scan and import what runs today.
Point the platform at a cloud account. It reads the whole stack, reports what it found, and you group what is there into Fractals. Nothing is modified while it reads.
From that moment your estate is visible in one place and under management: versioned, policy checked at deploy, continuously reconciled.
Bring in the Terraform you wrote.
Two routes, and you choose per module. It can be read and rebuilt as a Fractal, so it becomes reusable and portable. Or it stays Terraform, wrapped in a component the platform governs.
Teams that write HCL keep writing HCL. Nothing has to be rewritten to start.
You optimize from what you already own, and the benefits arrive on the first system rather than at the end of a program.
Six things the engine does continuously.
See it against your own estate.
Start with discovery on one account, or walk through the model with an architect.