Proofline

Proofline is a verification-first autonomous agent for work that must be proven, not merely declared complete. It turns a task contract into explicit requirements, evaluates fresh authoritative evidence, detects contradictions, and produces a tamper-evident proof packet. External submissions remain behind an explicit human-approval gate.

See the contradiction before the claim: watch the 46-second continuous evidence run. It follows one synthetic fixture from conflicting sources to recheck, human approval, and a sealed packet. Teams can also request a fixed-scope evidence audit or implementation sprint from that page.

Need this evidence gate on your workflow?

• Start with a $59 fixed-scope evidence diagnosis to identify missing, stale, or contradictory proof.
• Book the $249 48-hour verification sprint for a working evidence gate and proof-packet workflow.

Both are one-time services with no subscription or automatic renewal.

Arm Create 2026: Cloud AI optimization

This repository includes the Proofline on Arm challenge work. During the challenge, the deterministic evidence gate was changed from a repeated requirements-by- evidence scan to a single authoritative-evidence index, reducing its matching work from O(R x E) to O(R + E).

On one Google Axion c4a-standard-1 host, the preserved baseline processed a median 62.539 proof packets/second and the optimized evaluator processed 98.414 proof packets/second: a measured 1.5736x speedup, or 57.36% higher throughput. The decision and deterministic packet hash were identical, and all 15 tests passed on the same Arm64 host.

Judges can start with the complete Arm Create submission brief and the raw, reproducible Google Axion evidence.

This project was started on 2026-08-05 for Google's All Things Agentic Hackathon. It is a new project in the Taskmaster category.

Why it matters

Teams lose time when a marketplace listing is stale, a deployment is assumed to work, or a deliverable is called complete without evidence. Proofline makes the acceptance boundary executable:

1. Decompose the task into requirements.
2. Collect or receive evidence from authoritative sources.
3. Reject stale, missing, or contradictory evidence.
4. Build a deterministic, hash-addressed proof packet.
5. Pause before any external submission until a human approves it.

Google stack

• Gemini 3.6 Flash for requirement decomposition and evidence interpretation.
• Google Agent Development Kit (ADK) for the agent and its tools.
• Firestore for durable proof packets and execution state.
• Cloud Run for the hosted agent API.
• Pub/Sub for asynchronous rechecks and long-running verification jobs.

The deterministic verification core runs without cloud credentials, so judges can inspect and test its safety boundary locally.

Local verification

python -m unittest discover -s tests -v
python sample_run.py
python demo_matrix.py

demo_matrix.py renders one deterministic packet for each possible decision: NEEDS_EVIDENCE, CONFLICT, APPROVAL_REQUIRED, and READY. It uses only synthetic public-safe fixtures and a fixed UTC evaluation time, so judges can reproduce the same four packet hashes without credentials or network access.

Arm64 evidence workflow

The candidate Arm Cloud AI work is kept separate from the existing Cloud Run submission. On an actual aarch64 or arm64 host, run:

./scripts/run_arm_evidence.sh

The runner refuses non-Arm hosts, executes the test suite, performs at least three deterministic benchmark repetitions, and writes the evidence under artifacts/arm64/. No Arm performance improvement is claimed until those artifacts exist and the measurements support it. The script does not create cloud resources or change billing.

The verified Google Axion run and its exact measurements are documented in docs/arm-axion-evidence.md.

The Arm challenge branch also replaces the evaluator's repeated requirements-by-evidence scan with a single evidence index. The reproducible comparison in benchmarks/arm_optimization_benchmark.py runs the preserved baseline and optimized implementation in alternating order, rejects any proof packet difference, and records both rates plus the measured speedup. Arm64 performance is not claimed until that comparison is rerun on Axion.

For a disposable cloud VM, use the guarded one-shot wrapper:

PROOFLINE_AUTO_POWEROFF=1 ./scripts/run_arm_cloud_once.sh

It enforces a 20-minute default timeout, archives and hashes the evidence, and powers off the VM on both success and failure. Automatic power-off is disabled unless PROOFLINE_AUTO_POWEROFF=1 is set explicitly, preventing accidental shutdown during local development.

The ADK agent folder follows Google's discovery convention and contains its own deployment requirements file. Deployment instructions are in docs/deployment.md, and the system diagram is in docs/architecture.md.

The credential-free ADK API preflight, measured endpoint results, and exact reproduction commands are recorded in docs/local-api-evidence.md.

The contest-requirement matrix and public endpoint checks are recorded in docs/submission-evidence.md.

Live deployment

Proofline is live on Google Cloud Run in europe-west1:

https://proofline-343140361830.europe-west1.run.app

A continuous 46-second product walkthrough is also embedded on the public Proofline page:

https://daradigu.com/proofline

It shows evidence collection, a promise mismatch, a fresh recheck, the human approval boundary, and the sealed packet in one uninterrupted sequence. The walkthrough uses synthetic fixtures, contains no customer data, and is explicitly labelled as AI-assisted. Teams that need the same verification boundary can use the page to request a fixed-scope diagnosis or implementation sprint.

The public ADK API is deployed as revision proofline-00001-rqw with zero minimum instances, one maximum instance, 512 MiB memory, one CPU, concurrency 20, and startup CPU boost disabled. On 2026-08-05 an external verification returned HTTP 200 and ["proofline"] from /list-apps, created a real ADK session, invoked Gemini 3.6 Flash, called the deterministic evaluate_packet tool, and returned READY with packet hash 973750f90ceffd925eba6716399f9064fcc789522ae8455efe764ef6c841eb5d.

Planned hosted flow

Task -> Gemini/ADK planner -> Pub/Sub verification jobs
     -> authoritative evidence -> deterministic gate
     -> Firestore proof packet -> human approval -> external action

No customer data is included in the repository. Demo fixtures are synthetic.

Current status

• Deterministic evidence gate: implemented and covered by six unit tests.
• Google ADK agent: implemented with a guarded local-development import.
• ADK serving application: exported through the current App wrapper with a retry-configured Gemini model and an agents-cli Cloud Run manifest.
• Cloud Run container: reproducible root Dockerfile starts the ADK API server on the platform-provided port and excludes local secrets from the image.
• Cloud Run: publicly deployed and verified end to end with Gemini and the deterministic evidence gate. Firestore and Pub/Sub remain documented extension points and are not required by the current in-memory demo.
• Devpost project: officially submitted to the All Things Agentic Hackathon at https://devpost.com/software/proofline-65a8t4. The current public walkthrough is the 46-second continuous evidence run. No prize or revenue is claimed unless an organizer confirms an award and payment.
• Demo preparation: the 3:45-4:00 recording plan is in docs/demo-video.md. The live Cloud Run evidence above is the authoritative source for its hosted segment.