Fluxive internal

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.

The console is being brought back.

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.

  1. Compile the governance spec with @mforce/builder, the single source of truth for what a unit may do (its CALM envelope).
  2. Codec writes the authority envelope.
  3. Gauge runs the behavioural proof (the quadruplex gate).
  4. Nucleus compiles the life certificate and seals the version.
  5. 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.

  1. In the Runtime Foundry, open Pipeline and create a draft from the current config.
  2. Move it to test.
  3. Validate it. This runs a probe build against the candidate and checks the class permissions resolve. A config can only go to prod if it was validated in the last 24 hours; the engine enforces this, not the page.
  4. 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.

  1. Open Catalogue, pick or create the archetype, and edit a draft version.
  2. 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.
  3. Test it: a test build reports the allowlist the unit would be signed with.
  4. Move it through test to prod. 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.

CallWhat it does
GET /factory/healthHealth. Public; the detailed body needs the service key or a team sign-in.
GET /api/factory/build/versionThe compiler and pipeline versions builds use now.
POST /api/factory/buildBuild one unit: compile, certify, version, return it.
POST /api/factory/build/attest/aggregateAttest an aggregate (a FluxBot and its parts).
POST /api/factory/compile-policyCompile policy text into governance.
GET /api/factory/archetypes/publishedThe published catalogue. Public, read-only.
/factory/pipeline, /factory/archetypes, /factory/compilerThe 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

WhoWhat they get
Not signed inThe sign-in page (Launch). Engine APIs answer 401.
Signed in, not @fluxive.aiTurned away from every page, and from the engine APIs.
Signed in, verified @fluxive.aiThis how-to. The console is in Fluxive Science.
A machine with the service keyThe 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.