Inspiration
My day job is business operations in the enterprise-equipment channel, and the chore I brought to this hackathon is one I personally live with: preparing the bid package for an equipment procurement tender. The friction is real and recurring. Requirements arrive scattered across documents. Every qualification and product claim must be backed by a specific piece of evidence. Pricing must stay consistent across the quotation, the bill of materials, and the summary. And one missing project-specific manufacturer authorization can invalidate an otherwise perfect package on the spot.
Chat assistants can summarize this work; they cannot be trusted to finish it. Finishing means producing files a reviewer can actually sign off on—and never papering over a gap with something plausible. ProofBid is my answer: an autonomous background agent that either completes a fully validated preparation package, or blocks honestly on the exact missing evidence and still delivers a reviewable remediation package. Signing, pricing freeze, sending, and submission stay locked by design.
What it does
One synthetic tender event starts a background workflow: React fires the event, FastAPI on Cloud Run accepts it, a Cloud Run Job executes the agent, and Cloud Storage holds task state, receipts, and deliverables.
Inside the Job, a Gemini 3.5 Flash agent built with Google ADK FunctionTools drives the run. Gemini's decision rights are real and specific: it chooses the order of registered tools within enforced dependencies, decides when analysis is sufficient to proceed, chooses the correct terminal branch (complete versus blocked), and may choose exactly one legal retry after a transient renderer failure. Deterministic domain code owns everything a bid reviewer must be able to trust: requirement extraction, evidence matching, BOM and pricing arithmetic, readiness gates, document rendering, and cross-artifact validation.
The green case ends with 12/12 requirements matched against 63 evidence references and delivers a validated Word/Excel/JSON/Trace/ZIP package with both readiness flags true. The blocked case—identical except that the single project authorization is removed—ends with exactly one missing item, the stable reason code PROJECT_AUTHORIZATION_MISSING, both readiness flags false, and still delivers a validated evidence ledger and remediation package. Nothing is fabricated to make a result look complete.
Data sources
All public data is synthetic by design. The fixtures model an enterprise equipment procurement tender with installation and delivery obligations: equipment supply, transport, installation, training, acceptance, warranty, bidder qualifications, and a project-specific manufacturer authorization.
The hosted workbench exposes exactly two built-in cases—complete_tender and blocked_missing_authorization—that differ by a single variable: the presence of that one authorization. This is a deliberate privacy and truthfulness boundary, not a hidden limitation. Real tender documents are confidential, and a fixed single-variable pair lets judges verify that completion and blocking are driven by evidence, not by prompt luck. ProofBid does not claim production-wide coverage of arbitrary tender documents; real-document parsing is the next product step, listed below.
How we built it
- Google ADK
Agent,Runner, and a boundFunctionToolregistry; - Gemini 3.5 Flash through Vertex AI ADC;
- Cloud Run Service for the React/FastAPI event API;
- Cloud Run Job for the autonomous background execution;
- Cloud Storage for task state, Trace, receipts, and delivery artifacts;
- deterministic Python domain logic, openpyxl, and python-docx;
- React/Vite workbench and Playwright desktop/mobile verification.
The model cannot supply paths, shell, SQL, URLs, prices, evidence, or business facts. A server-side state machine enforces tool dependencies, input digests, call budgets, one bounded retry, and deterministic terminal gates. Each tool receipt is chained by SHA-256 and packaged with the final manifest.
Challenges
The hardest design problem was making agent autonomy visible without allowing the model to become the source of truth. The obvious critique of any safety-first agent is "isn't Gemini just a thin wrapper around a pipeline?"—so we made the division of power explicit. Gemini owns routing decisions that genuinely change the run: tool order, terminal branch, and bounded recovery. Deterministic code owns facts, calculations, rendering, validation, and release. Every FunctionTool call carries a real ADK function_call_id and lands in a SHA-256-chained receipt, so a judge can audit exactly which decisions the model made.
We also had to distinguish a truthful business blocker from a technical task failure, so that an incomplete bid still produces a valuable, validated remediation package instead of an error page.
Accomplishments
- three genuinely different verified routes: complete, blocked, and one bounded renderer recovery;
- zero implied submission actions:
submission_executed=falseandhigh_risk_actions_locked=trueare invariant contract fields; - cross-artifact Word/Excel/JSON/ZIP validation and an exact-set manifest;
- 50/50 local synthetic Eval cases across structure, missing evidence, product/pricing, prompt injection, and recovery;
- a public-safe two-case workbench with no arbitrary upload, plus real Cloud Run Job executions reconciled across provider receipts, logs, revision/image digests, and GCS/Service ZIP hashes.
What we learned
Agent autonomy is strongest when its decision rights are explicit. A constrained tool router can still be meaningfully agentic if it chooses recovery and terminal branches, while typed deterministic tools protect professional truth and safety.
What's next
After the competition demo, the next product step is versioned public-document parsing and human approval receipts—not automated signing or submission.
