SYNXThe sovereign AI control plane.
Next: governance as PID 1.
Cooperative governance — a library your code agrees to call — is not governance. SYNX governs autonomous AI inside your boundary — your metal, your VPC, or a machine with no network at all — and it can govern a pipeline you already run. Routing, constitutional validation, precedent and the integrity chain run with no model, and every run carries a cryptographic proof you check yourself. The operating-system image goes further: governance boots first, as process one, and nothing runs that it did not admit. That image boots in test; it is not yet the production path, and release signing remains. No sign-ins to us. No data through us.
No human in the loop. Start to finish.
Since SAE J3016 — where the Level 0–5 vocabulary comes from — Level 5 has meant one thing: the system completes the work with no human intervention. It has never required the system to rewrite its own rules. We know of no other system in the published record described as operating there. SYNX does, and the records are dated.
Run figures: the factory's ledger, read 22 Sep 2026. Product count: the store, 29 Sep 2026.
The refusal rate is the point. A system that ships everything is a generator. One that rejects three runs in four — for an empty file, a promise the package did not keep, a legal screen that could not be reached — is exercising judgment, unattended. It even pulled its own listings rather than leave a mismatch on sale.
Feel the burst. No account.
Other tools run a chain in sequence — 1→2→3, every step waiting on the last. SYNX rotates the chain and bursts at it, so every unit runs in parallel. This is the real 30-node pyramid: click any node to see the job it actually does, switch base nodes off to feel elastic ceremony (fewer nodes, identical proof), flip a tier cognitive and watch the LLM-call cost move — then fire it.
execution profile
cognitive tiers
click any node to see its real role · double-click a base node to switch it off · then fire the burst. SYNX doesn't chain 1→2→3 — it rotates the chain and fires every unit in parallel.
Read live from https://api.frontpaygtech.xyz/health in your browser — open it yourself. This is the same installed core that governs every job and seals every proof, and it runs inside your own boundary when you deploy it. Here it is the reference deployment: one CPU-only virtual machine, which hands every governed run except this demo to SYNX's own product factory as an outside pipeline.
The live core is one CPU-only machine, where a governed run takes about 10 to 25 minutes. The demo stops a run at 15 minutes and records it as failed, so a run can fail on time alone. Keep this tab open.
A governed platform, inside your boundary.
SYNX Core — governance as execution
Routing, constitutional validation, precedent, and the integrity chain run with zero model inference — a model can propose, it can never approve itself. When the two halves of a run disagree, precedent settles it if precedent exists, and a clause settles it if the clause names the side. Otherwise the Digital CEO, a certified model, rules and must write down why, and that ruling becomes precedent. A true deadlock also goes to a human: the CEO's ruling holds for that job only, and the human's ruling becomes permanent Case Law. Flow never stops, and every choice is on the record.
Level 6 workbench
Agent Forge, the burst board, and the constellation canvas — your team composes, tests live against the local core, and promotes the same composition to production.
Cryptographic provenance
SHA-256 hash chain + root proof per run, text and binary artifacts alike. The offline verifier recomputes every node — its content digest and all of its children — up to the root, and checks the root against the deployment's signature with a key you pinned, on your machine. The verifier page says what it does not check.
Bring your workflow definitions
Import a CrewAI crew, an n8n workflow export, or a plain list of steps, and SYNX works out which steps can run side by side and which must wait — from the workflow's own dependencies, never guessed. It imports definitions, not runtimes: the steps and objectives carry over; custom state handling, tool callbacks and your own external calls stay in your stack. Chains written as code (LangChain, LangGraph) are programs; SYNX does not translate them. Keep them running and govern them as your own pipeline.
Govern a pipeline you already run
Your own pipeline can take the place of SYNX's execution core. It is admitted only as a certified asset — signed, expiring, revocable — and its address comes from that certificate, never from configuration. SYNX rules on each job before it is sent and on what comes back. The proof says plainly what it covers — the admitted request, who ran it, the exact bytes returned — and what it does not: your pipeline's internal steps. A job sent out is sent at most once; self-healing never re-sends it. Revoke the certificate and the next job is refused, with no restart. SYNX's own product factory takes governed work this way today.
Certified by behaviour
An unknown model is tested, not refused, and certified only for the roles it earns: keeping to an output contract, refusing an obviously bad product, and ignoring an instruction planted in the data. Judging requires all three. The product ships no vendor models.
Air-gapped, proven
A signed offline kit, installed as an upgrade on a clean machine with no network, sealed so the kernel itself refuses any outside connection. A real governed job ran there and its proof verified. A from-nothing install on a new machine is the next test. Licensing is a signed file checked locally — no callback, ever.
Plans onto your hardware
One scan at install and at run time places each workload on what the machine has. Proven on an NVIDIA data-centre GPU, a Windows integrated GPU, and a CPU-only ARM machine. AMD and Apple GPUs are not yet proven on hardware.
Read-only access for auditors
Named, expiring, read-only keys, scoped by team. An evaluator or auditor sees every run its team is allowed to see — every run, if you grant it — with its governance record, its node trail (for runs on SYNX's own burst) and its proof, and can watch a run's governance as it happens: which clause governed each step, and where the integrity chain stands. Never what the run produced, which stays with whoever ran it.
Governance cost-to-zero
Governed decisions harden into precedent and are reused at zero marginal tokens. Inference is still metered per job — it is the governance overhead that trends to zero as precedent accumulates.
A Constitution from operation
The rules SYNX governs by were written from what broke in real runs, and precedent is earned by real rulings — never written in by hand. A dry run tells you, before anything starts, which model would do each part, without calling one.
Libraries give your team code. SYNX gives them a platform.
Agent frameworks
- Governance is middleware — more tokens, more prompts, more hope
- A hallucination can enter control flow
- Compliance is a separate audit project
- Your workloads run through someone else's cloud
SYNX Level 6
- Governance is the execution layer — routing, validation and proof at zero tokens
- Model output cannot approve itself past validation
- An auditor gets a read-only key to the runs you grant, each with its record and its proof
- Installed in your boundary — nothing leaves unless you route it out
Not yet proven: multi-node or Kubernetes operation, the effort of integrating with your existing workflow, and governance as process one in production. No compliance certification has been performed. The full list is on the product page.