The ecosystem

One factory. Every platform. Models that learn.

LeanLogix is the model factory inside an AI-native delivery ecosystem built for global service providers and their frontier-model alliances. A platform plugs in and gets a model trained specifically for it; governed experience makes that model better; every release ships signed, offline-verifiable evidence.

Talk to the factorySee the models

89

SprintLoop-7B v6 · 50-probe hard suite · signed

96

Portfolio Router · held-out routing · +20 vs base · signed

100%

Refusal probes held — measured, committed

8

Governed stages from experience to signed release

The Experience Loop

The more a platform uses its model, the better the model gets

Recursive learning as a governed lane, not a policy bypass. Each stage emits the artifact named beside it — the loop's history is auditable end to end.

01CaptureThe platform streams experience — interactions, tool-call traces, human corrections and approvals, call transcripts — under a recorded client consent scope. No consent, no capture.emits · consent scope · agreement reference · recorded approver
02IngestEvery event passes the data-policy scanner before anything reaches a store. PII-, PHI-, or secret-shaped content that a model could learn to emit quarantines the event.emits · ingestion receipt · quarantine counts · store digest
03CurateAccepted experience becomes training pairs — corrections carry the most signal — and the scanner runs again on the output. Customer data stays outside version control; only manifests and receipts are committed.emits · curation manifest · pair counts · policy verdicts
04TrainThe Foundry lifecycle runs the cycle: probe suite registered before training, one variable per iteration, adapter-first on the platform's base model.emits · run record · config digest · adapter sha256
05EvaluateThe candidate is measured against the incumbent on the registered suite. A regression cannot be promoted — the gate refuses, mechanically.emits · eval reports (candidate + incumbent) · deltas
06ProposeThe system reads accumulated experience and the latest results and writes the next training cycle itself — a machine-generated plan with a rationale. Proposals carry no authority.emits · proposal record · config diff · rationale
07PromoteA named reviewer who is not the trainer approves the release; separation of duties is recorded in lineage. Channels advance one step at a time and never skip.emits · lineage.json · reviewer identity · transitions
08Sign & serveThe release is Ed25519-signed by the platform and served inside the client's boundary. Anyone can re-verify the passport offline — no dashboard trust.emits · signed release manifest · public verify endpoint

The loop is driven by one CLI (`foundry ingest → curate → train → eval → propose`) with a committed run ledger. The lifecycle and its fail-closed gates are documented in the framework.

Governance is the product

Built for regulated operations

The discipline that regulated environments require is engineered into the lane itself — which is exactly what makes the resulting models deployable where it matters.

Consent before captureEvery experience event carries a recorded client consent scope; events without one are refused at the door.
Two policy gatesThe PHI/PII/secrets scanner runs at ingestion and again at curation output — both fail closed.
In-boundary by defaultClient experience trains the client's own boundary; shared models take only synthetic distillation.
Weights never in gitAdapters are referenced by sha256, size, and storage path in signed manifests — never committed.
Proposals have no authorityAI generates the next cycle; promotion always passes a human gate with separation of duties.
Evidence, not assertionsModel card, dataset card, eval reports, lineage, and release manifest are generated from the run itself.

What plugging in looks like

A model trained for your platform

The factory has run this lifecycle end to end for the portfolio's own platforms — coding agents, routing, healthcare candidates, contact-center intake. Each began exactly where a partner platform begins: a base model, a domain corpus, a probe suite, and the governed loop.

Explore the model index for the measured evidence behind each release, or the methodology for how a release earns its signature.

Plug your platform into the factory

Bring the platform and the domain; the factory brings the lifecycle, the governance, and the evidence discipline. Models engineered for regulated environments, improved by experience, signed on release.

Start the conversationBrowse the models