Our submission Helixstreet — autonomous genomic fleet won Best Architectural Design in Google's All Things Agentic Hackathon — one of the largest AI agent hackathons ever held, featuring $180,000 USD in prizes and a field of 12,260 participants — under Track: The Fortified Enterprise Fleet.
Most "AI agents" shipped today are chatbots with tool definitions attached. For a genomic pipeline, a chat loop is the wrong abstraction: nobody wants to sit in a prompt window while a variant caller runs across aligned sequencing reads. We built the opposite — an event-driven fleet with no chat loop anywhere. Raw sequencer output lands in a storage bucket; infrastructure events wake a governed five-agent fleet that screens for compliance, dispatches Google DeepVariant on Cloud Batch, goes completely dormant while heavy compute runs, wakes itself when the VCF lands, cross-references 1000 Genomes in BigQuery and CPIC pharmacogenomic guidance, and seals a digital twin behind a hash-chained audit ledger and Merkle genome vault.
The live Streamlit command center on Cloud Run (dashboard.helixstreet.io) inspects the Firestore Memory Bank, Agent Registry, Merkle Genome Vault, and Hash-Chained Audit Ledger in real time under a read-only least-privilege IAM identity:
CYP2C19 *2/*2 clopidogrel alert).
prev_hash → entry_hash) re-verified from genesis on every refresh.
The architecture: dormancy over polling, deterministic routing over prompt soup
A genomic pipeline has a structural mismatch with request/response agent frameworks: intake and compliance take seconds, DeepVariant takes minutes on a chromosomal slice and hours on a whole genome, and downstream clinical/population annotation takes seconds again. Holding an agent process open across that gap wastes compute and dies on the first container restart.
1. Compliance screening, PII de-identification & cryptographic genome fingerprint
helixstreet_intake (running on Gemma 4 31B) screens the uploaded manifest with Model Armor (prompt-injection, jailbreak, malicious-URI Filters), de-identifies PII via Cloud DLP, and anchors a SHA-256 fingerprint of the raw BAM into the hash-chained audit ledger. helixstreet_variant_caller (Gemini 3.5 Flash on Vertex AI) dispatches google/deepvariant on Cloud Batch, checkpoints pipeline state to the Firestore Memory Bank — and ends its turn.
2. Dormant state bridged by Firestore Memory Bank
While Cloud Batch executes DeepVariant on dedicated compute, zero tokens and zero agent containers are held open. Whether the job takes three minutes (chr20 slice) or three days (cohort whole-genome batch), state lives in Firestore — not in memory.
3. Autonomous resume, 1000 Genomes + CPIC annotation & Merkle commitment
When DeepVariant writes output.vcf.gz back to Cloud Storage, Eventarc fires again. The deterministic router wakes the analysis pipeline with full prior context from the Memory Bank: helixstreet_analyst parses calls, queries 1000 Genomes Phase 3 in BigQuery, and seals a per-variant Merkle root into the Genome Vault; helixstreet_pharmacist screens against CPIC level-A drug-gene pairs with live Europe PMC literature; helixstreet_steward writes the final digital twin and closes the hash-chained audit trail.
The five-agent fleet
Built on Google's Agent Development Kit (ADK) (Agent, SequentialAgent, Runner), the fleet separates high-volume gatekeeping from multi-step reasoning:
| Agent | Stage | Model tier | Responsibility & tools |
|---|---|---|---|
helixstreet_intake |
Ingest | Gemma 4 31B | Screens manifests with Model Armor, redacts PII with Cloud DLP (with audited local fallback), records SHA-256 genome fingerprint. |
helixstreet_variant_caller |
Ingest | Gemini 3.5 Flash | Stages output prefixes, dispatches DeepVariant as an async Cloud Batch job, checkpoints to Firestore Memory Bank. |
helixstreet_analyst |
Analysis | Gemini 3.5 Flash | Parses VCF calls, cross-references 1000 Genomes allele frequencies in BigQuery, anchors salted Merkle commitments. |
helixstreet_pharmacist |
Analysis | Gemini 3.5 Flash | Matches genotypes against curated CPIC level-A pharmacogenomic rules (e.g. CYP2C19 *2/*2 clopidogrel activation) + live Europe PMC citations. |
helixstreet_steward |
Analysis | Gemini 3.5 Flash | Persists the structured digital twin and appends the closing entry to the tamper-evident hash-chained audit ledger. |
Why agents instead of a static workflow DAG?
A fair architectural question — and one we ask advisory clients all the time — is why this shouldn't just be a static Cloud Workflows YAML file. The answer is that routing between stages is deterministic (Eventarc triggers + regex router), while execution within each stage is agentic so the system absorbs real-world clinical and bioinformatics variability without brittle branching:
- Coordinate-system reasoning in live runs: During a live test run,
helixstreet_analystnoticed unprompted that the VCF produced by DeepVariant and BigQuery's1000_genomestable disagree on coordinates by one base pair (VCF is 1-based; BigQuery'sstart_positionis 0-based) and reasoned through the population-frequency lookup anyway. A naive join-by-position ETL would have silently returned zero matches. - Graceful degradation with explicit provenance: If an upstream API (such as Cloud DLP) is unreachable or throttled, the intake agent falls back to a local redaction scrubber and records which engine actually ran in the hash-chained audit trail.
- Missing or malformed manifests: When a sample arrives without a manifest, the intake agent logs a
MANIFEST_MISSINGaudit event and continues processing the alignment file rather than halting the batch. - Narrative compliance: Every ledger entry is written in context by the agent that performed the action — giving auditors a human-readable explanation tied to a SHA-256 chain rather than raw status codes.
Autonomy is an infrastructure property before it is a model property: exactly-once event handling, claim release on failure, durable state across dormancy, and platform-level identity are what let an agent fleet be trusted to act unattended.
Enterprise fleet pillars & self-healing under failure
Idempotency with claim release on failure
Eventarc delivers at-least-once. Claims are keyed per (bucket, object, generation) in Firestore so duplicate deliveries never re-run a pipeline — but failed runs explicitly release their claim and return 5xx, allowing Eventarc backoff to self-heal transient crashes or quota exhaustion without losing samples.
Right-sized hybrid model tier
Running a frontier reasoning model on every intake manifest at population scale is unnecessary spend. helixstreet_intake runs on Gemma 4 31B with native function calling for high-throughput gatekeeping, reserving Gemini 3.5 Flash on Vertex AI for multi-step bioinformatics and clinical synthesis.
Least-privilege IAM identity (no gateway hop)
Three isolated service accounts enforce blast-radius boundaries at the platform layer: the analyst can query BigQuery but cannot launch Batch compute; the Streamlit dashboard can read Firestore state but cannot invoke agents; the fleet ingress accepts only authenticated Eventarc identities.
Hash-chained audit ledger & Merkle vault — Proof of Original Life
Every tool call and state transition appends to a SHA-256 hash chain verified on every dashboard refresh. Called variants are committed to a salted Merkle tree in the Genome Vault — our human genome and the life forms of Earth are now safe with cryptographic methods. Nobody can tamper with a genome without changing its hash: we prove what is real, original life, preserving Earth's biological blueprints and helping bring them to Mars.
Five production bugs that hardened the architecture
Every resilience mechanism in the submission was earned by hitting a real failure mode during development:
- Global models vs. regional compute:
gemini-3.5-flashserves from Vertex AI's global endpoint, while Cloud Batch jobs require a regional endpoint. Splitting model location from compute region prevented silent routing failures. - The idempotency trap: Recording an event claim before pipeline completion meant a mid-flight failure caused Eventarc's retry to be dropped as a "duplicate." Releasing claims on failure turned a brittle deduplicator into a self-healing loop — proven live when a quota-exhausted run failed, released its claim, was redelivered minutes later, and finished with zero human intervention.
- GCS-FUSE's vanishing directories: Cloud Storage has no real directories;
mkdiron a FUSE mount creates a kernel-cached entry with no backing object that evaporates during a multi-minute DeepVariant run, crashing the final VCF write. The variant-caller agent now materializes a placeholder object before dispatching Cloud Batch. - Quota-aware concurrency: Concurrent agent pipelines on newly released models can cannibalize per-minute token quotas. Adding model-level
HttpRetryOptions(15s→120s backoff on429) and right-sized instance concurrency eliminated mid-pipeline thrashing. - Deterministic builds: An upstream transitive dependency release broke Cloud Build mid-hackathon. All 78 Python dependencies across both services are now strictly pinned from a verified lock environment.
Google Cloud Platform (GCP) stack & NVIDIA Nemotron evaluation
The fleet runs end-to-end on Google Cloud Platform (GCP), combining Google's agent framework, foundation and open-weights models, genomic deep-learning variant caller, serverless event routing, and zero-trust security primitives:
- Google AI Models & Agent Framework: Google Agent Development Kit (ADK) (
Agent,SequentialAgent,Runner), Gemini 3.5 Flash via Vertex AI (global endpoint), and Gemma 4 31B (gemma-4-31b-it) with native function calling for right-sized intake gatekeeping. - Genomic Variant Calling & Population Analytics: Google DeepVariant orchestrated asynchronously on Cloud Batch, plus population allele-frequency queries against 1000 Genomes Phase 3 in BigQuery.
- Serverless Runtime & Event Fabric: Cloud Run (hosting both the FastAPI ADK fleet and the Streamlit command center), Eventarc (
object.v1.finalizedtriggers with exponential retry), and Cloud Storage. - State, Guardrails & Observability: Firestore (Memory Bank, Agent Registry, hash-chained audit ledger, and salted Merkle genome vault), Model Armor (prompt-injection, jailbreak, malicious URI, and PII filters), Cloud DLP (de-identification), Secret Manager, Cloud Trace (OpenTelemetry span export), and Cloud Logging.
- Multi-Cloud & NVIDIA Nemotron Evaluation: As a member of the NVIDIA Inception program (since 2019, renewed 2026), we are also actively evaluating NVIDIA Nemotron models (
Nemotron-3 Nano 30Bfor high-throughput intake gatekeeping andNemotron-3 Super 120Bfor agentic tool-use) alongside NVIDIA Clara Parabricks GPU-accelerated DeepVariant for sovereign multi-cloud deployments.
How this connects to the Helixstreet chain
Helixstreet's core thesis on Polkadot is that raw genomes never belong on a blockchain — sequences stay in HIPAA- and GDPR-bounded enclaves while the chain coordinates consent receipts, narrow eligibility proofs, and provenance attestations.
The autonomous genomic fleet is the enclave-side counterpart to that settlement layer. From the moment a BAM file lands, the intake agent computes its SHA-256 genome fingerprint, the analyst agent constructs a salted Merkle tree over the called variants so individual alleles can be proven via compact Merkle inclusion proofs without disclosing the rest of the patient's genotype, and the steward seals the hash-chained audit trail. The enclave fleet does the heavy, regulated bioinformatics; the cryptographic commitments it produces are the exact primitives our on-chain provenance and consent pallets verify.