How to work with the Foundry
The Machineforce Runtime Foundry compiles every Machineforce Unit (MFU): it turns a unit's definition into a governed, certified, versioned build. This site is the how-to.
Dashboard, Pipeline, Compiler, Catalogue, Build Lab, Floor, Fleet and Docs moved into the web Fluxive Science on 2026-10-22, and that app was retired on 2026-11-05, so for now there is no console to open. Units are built through Control, which calls this engine. (2026-11-15)
factory.fluxive.ai itself is the engine: it answers machines (Control, Fluxive Science) and shows this page to signed-in team members. Nothing on this site changes anything.
How a unit is built
A unit's configuration is authored somewhere else (Control for an organization, the operator's own profile for My Machineforce) and sent to the Foundry. The Foundry compiles, certifies and versions it in one pass, then returns the built unit. It never writes the unit into a fleet; the caller does that.
- Compile the governance spec with
@mforce/builder, the single source of truth for what a unit may do (its CALM envelope). - Codec writes the authority envelope.
- Gauge runs the behavioural proof (the quadruplex gate).
- Nucleus compiles the life certificate and seals the version.
- Manifest: a reproducible record of what was built, with which compiler and which pipeline config.
The active pipeline config decides the compiler version, the class permissions and the drift threshold for every build. The compiler version a unit was built with travels inside it.
Promote a pipeline config
Pipeline configs move dev → test → prod → archive. Exactly one config is prod at a time; promoting a new one archives the old one.
- In the Runtime Foundry, open Pipeline and create a draft from the current config.
- Move it to
test. - Validate it. This runs a probe build against the candidate and checks the class permissions resolve. A config can only go to
prodif it was validated in the last 24 hours; the engine enforces this, not the page. - Promote it to
prod. Builds from that moment use it.
Publish an archetype
An archetype is the versioned template for a kind of unit (for example a homework helper or an AP clerk). Archetypes use the same lifecycle: dev → test → prod → archive. Only prod archetypes are published to Control and the operator app.
- Open Catalogue, pick or create the archetype, and edit a draft version.
- Choose its action classes from the picker. The list comes from the compiler's own table, so a class the compiler does not know cannot be chosen.
- Test it: a test build reports the allowlist the unit would be signed with.
- Move it through
testtoprod. Control reads the published list at/api/factory/archetypes/published.
Check the compiler
Compiler in the Runtime Foundry is the register of every @mforce/builder version this Foundry can resolve: what each one does with the same governance input, where behaviour changed between versions, the fixtures it is tested against, the version matrix, and a diff between any two versions. Add a fixture when you change what a version should do, then run the matrix.
Run a test build
Build Lab sends a build to the active pipeline config and shows the certified result: the compiled governance, the life certificate, the manifest and the attestation. Use it before promoting a config or an archetype.
Call the engine
Machines call the engine with the fleet service key in the X-MForce-Auth header. The key is the shared secret mforce-service-key; it is never put in a browser.
| Call | What it does |
|---|---|
GET /factory/health | Health. Public; the detailed body needs the service key or a team sign-in. |
GET /api/factory/build/version | The compiler and pipeline versions builds use now. |
POST /api/factory/build | Build one unit: compile, certify, version, return it. |
POST /api/factory/build/attest/aggregate | Attest an aggregate (a FluxBot and its parts). |
POST /api/factory/compile-policy | Compile policy text into governance. |
GET /api/factory/archetypes/published | The published catalogue. Public, read-only. |
/factory/pipeline, /factory/archetypes, /factory/compiler | The authoring APIs the Runtime Foundry console uses. |
curl -s https://factory.fluxive.ai/api/factory/build/version \ -H "X-MForce-Auth: $MFORCE_API_KEY"
A build needs name and owner. The organization (owner_fleet, a fleet UUID) and its tier come from the trusted caller, never from the unit's own input.
Who can reach what
| Who | What they get |
|---|---|
| Not signed in | The sign-in page (Launch). Engine APIs answer 401. |
Signed in, not @fluxive.ai | Turned away from every page, and from the engine APIs. |
Signed in, verified @fluxive.ai | This how-to. The console is in Fluxive Science. |
| A machine with the service key | The engine APIs. |
Names
The product was renamed from Factory to Foundry. A Google Cloud project id can never be renamed, so the deployment keeps its old identity: project and Cloud Run service mforcefactory, host factory.fluxive.ai. When a log line says mforcefactory, it means the Foundry.