Role scope
The public EU path starts with a role-and-scope gate. The exported Builder form chooses the route before any client-facing package run starts.
Technical Overview
Technical Overview: from agent runs to an EU AI Act package
Use this page to understand how the EU path works on your own system: what you can test on your own agent, what the engine produces, and where your team still takes over. The public site starts from a role-and-scope gate; many teams begin on the high-risk provider branch, but deployer, authorised-representative, public-authority, and Article 50-only paths are also supported.
Public path
What should already be visible before deeper integration
A serious product should expose a clear package boundary, explicit verify gates, and a real self-serve starter before your team commits to deeper integration.
- Readable EU report with article-level outputs
- Reviewer-facing package for handoff, not only internal screenshots
- Self-serve starter for the first technical fit check
Before deeper integration
What to check first
Before deeper integration, check three things: what the engine outputs, where your team takes over, and what you need for a first run.
Real outputs
The product ends in a portable report, compare-report JSON, manifest, retention controls, section-completion and package-completion records, and article-level EU outputs linked back to the same bundle. Article 50 evidence is added only when that branch is requested.
Package outputs
The EU path produces Annex-shaped documentation outputs, role- and scope-gated JSON artifacts, closing-package records, and starter results tied back to the same runtime evidence. Article 50 can be packaged separately, or added to the full package only when you request it.
Hard gates and source-visible path
Packaging and verify have explicit checks, and the commands, schemas, and artifacts are visible in the repository and reflected in the public Builder and starter path.
What your team must already have
A reachable adapter, a clear release boundary, starter cases, named owners for thresholds and sign-off, and an exported route file from the Builder are enough to test fit honestly before deeper integration.
What this technology actually does
The product turns comparable runs into a role- and scope-gated EU package, keeps the machine-verifiable core intact, and layers package structure and handoff on top without pretending to automate legal sign-off.
Evidence generation
- Comparable baseline and new runs become a portable evidence bundle
- The bundle includes a report, machine contract, manifest, retention controls, role- and scope-gated EU outputs, and an optional Article 50 module when you request it
- EU dossier sections attach to the same verified runtime evidence instead of diverging into a document-only workflow
Verification and gates
- Packaging and verify are explicit steps, not implicit dashboard output
- Review checks and authority packaging have hard prerequisites
- Strict mode can verify a signed manifest when authority-facing authenticity matters
Review and handoff
- The package can move across engineering, governance, counsel, procurement, and authority-facing review
- Readable package outputs, review records, handoff notes, and authority bundles can sit on the same package surface
- The goal is a package another reviewer can inspect without internal dashboards, screenshots, or unsigned file swaps
Honest boundary
- The product does not decide legal classification or sign-off
- Policy thresholds and residual-risk judgments still belong to named humans
- The strength of the system is evidence operations, not legal automation
Self-serve EU starter
First self-serve EU starter
Use the EU starter guide after exporting the route from the Builder when you want the first runnable compatibility check and a lightweight EU-shaped package on your own agent before deciding whether you need paid help.
What it shows
- The toolkit can reach your adapter and produce a lightweight EU-shaped starter package after the route is fixed.
- You can see how the EU minimum path starts on your own infrastructure, not only on the demo.
- Your team gets an honest first signal before deciding whether paid help is worth it.
What it does not do
- It does not replace the real role- and scope-selected package for review.
- It does not replace reviewed cases, comparable runs, or final legal completion.
- It does not let the client-facing route skip the exported form gate.
- It does not replace hands-on help when your team wants the real package on its own agent.
Workflow
What your team provides and what the engine does next
The middle of the decision should stay practical. Your team brings a reachable adapter, a real change boundary, starter cases, and named owners. From there the engine handles comparable runs, verified packaging, and role- and scope-gated EU outputs on top of the same bundle.
Your team exports the Builder route first so the package path is explicit before any client-facing run starts.
Your team exposes a reachable adapter and the baseline/new boundary that is actually worth reviewing.
Your team supplies starter cases, intended-use context, and named owners for thresholds and sign-off.
The engine runs comparable executions, packages the bundle, and verifies integrity and structure.
The engine generates the selected EU outputs from that same verified bundle; legal judgment and final approval still stay with your team.
Human-owned
What still stays human-owned
The strongest part of the product is the path from prepared inputs to a verified evidence bundle. Scope judgment, policy thresholds, adapter-depth decisions, and final sign-off still stay with named humans.
- Intended use: Owner-defined system purpose and boundary.
- Business harms: Impact and residual-risk framing stay with the operator.
- Approval/block policy: The toolkit cannot choose governance thresholds for the team.
- Final narrative and signoff: Release, compliance, and legal approval remain human-owned.
Next step
If the starter looks real, choose the fastest next step
If your team wants us to help set up and run the first real package, go to pricing.
FAQ
Frequently asked questions
What should a technical team verify before integrating?
Check the package boundary, the explicit verify gates, the split between machine-generated outputs and provider-owned completion, and the public self-serve path.
Can we test this on our own agent before deeper setup?
Yes. The EU starter guide is the shortest honest path from the public draft flow to a lightweight EU starter package on your own running adapter.
Do we need to read filenames and raw JSON first?
No. Start with the fit checks on this page. Open the EU starter guide for the runnable first check, and go to pricing when the starter looks real.
Does the toolkit automate legal approval?
No. It automates evidence operations and packaging. Legal classification, residual-risk judgment, and final sign-off remain human-owned.