Agent speed, agent boundaries
Coding agents produce Rust faster than anyone can review it. The Job is the acceptance layer between agent output and trust.
Use case — Rust
Memory-safe code, verified like it matters.
Systems Rust and agent-generated Rust get the same treatment: frozen criteria, a real build, a real test suite, a signed report.
The memory-safety push in government and enterprise is changing what "verified" means for Rust. A Job freezes the definition of done in a contract file, runs the build and tests in an independent environment, and returns a signed report whose evidence you can re-check offline.
Start a Rust JobA Rust Job, end to end
falsegreen.toml · frozen contract
↓ independent build
cargo build · cargo test
↓ signed result
report + dependency manifest
Why Rust
The code is memory-safe. The question is what else is true.
Rust's guarantees cover a class of defects. They do not answer: did this change do what the requirement says, in this build, with these dependencies, under these tests? A Job answers that with the repository's own tools, run where the agent and its self-report cannot reach.
Compliance-shaped evidence
The signed report — contract identity, per-criterion results, environment capture, dependency hashes — is the artifact an audit asks for.
Re-checkable offline
The report carries its signature and its evidence. Verification of the report does not require the platform.
Real evidence
What a Rust Job actually produced.
The evidence below is from real Jobs on the 0.4.0 platform — job identifiers, verdicts, and report contents, not illustrations.
Real 0.4.0 Job
Job bae84f54 — verdict Accepted
A real Rust workspace through the 0.4.0 platform: the frozen criteria ran in an independent environment; the signed report carries the dependency manifest with per-artifact hashes.
The frozen criteria
cargo build --offline · cargo test --offline
The Job's contract is the file in the repository. The verifier re-derives its identity from the file — the criteria cannot drift between declaration and verification.
End-to-end, through the live Internet
Rust lane: green
The hosted end-to-end world ran the Rust lane over the real network path: dependency resolution from the approved crates host, then a sealed offline build, with the online evidence preserved in the signed report.