ARCHON

Inspiration

Every large campus (hospitals, universities, enterprise real estate) runs on tribal knowledge locked inside the heads of facilities directors and chief engineers. When a water main breaks at 2am or a transformer overheats during peak occupancy, response coordination happens through phone calls and spreadsheets. When that person retires, decades of institutional memory walk out the door with them. We wanted to build something that treats that memory as infrastructure, not an afterthought.

What it does

ARCHON deploys seven specialist AI agents, built on Google ADK and Gemini, that classify incoming signals, map blast radius across buildings and systems, coordinate vendor dispatch, check regulatory compliance, and track remediation, all while a deterministic safety kernel enforces twelve hard governance invariants underneath the agent reasoning. Every incident's outcome is curated into institutional memory so the same lesson never has to be relearned.

How we built it

We separated the system into two layers on purpose: Gemini-powered agents propose actions, and a pure Python safety kernel decides whether those actions are actually allowed to happen. Model Armor screens every external signal for injection and PII before it reaches an agent. The Agent Gateway enforces financial thresholds, domain scoping, and rate limits. Every incident closes with a cryptographically signed state hash that an offline verifier can independently recompute, with no model call and no network access, to confirm the twelve invariants actually held.

Challenges we ran into

Regional payment infrastructure meant we couldn't get a Google Cloud billing account running in time for Cloud Run or Vertex AI Agent Runtime, so we rebuilt the deployment path onto Replit and Vercel while keeping Firestore as the real Google Cloud backbone. The harder challenge was proving our own governance layer actually worked rather than just claiming it did. We deliberately broke two invariants on purpose and confirmed the verifier caught each one specifically, with the other ten staying green, before we trusted our own numbers.

Accomplishments that we're proud of

Getting a verifier that can fail on command, not just pass. Most safety claims in a hackathon are asserted; ours are checked twice, once live during the incident and once independently afterward from a stored snapshot with zero shortcuts. We're also proud of being upfront about what's real and what's a disclosed substitute (Ed25519 signing standing in for Cloud KMS, Firestore Security Rules standing in for full per-service IAM isolation) rather than overstating either one.

What we learned

That a governance claim is only as strong as the failure case you can produce on demand. It's easy to write "financial threshold enforced" in a README. It's a different thing entirely to hand-craft a violation, run it through your own verifier, and watch it correctly say FAIL with the exact invariant named. We also learned a lot about where ADK's agent delegation and callback lifecycle genuinely require careful handling versus where it's forgiving.

What's next for ARCHON

Closing the infrastructure gap with real per-agent Cloud Run isolation and managed Vertex AI Memory Bank once billing access is resolved. Beyond the hackathon, we see this pattern extending past facilities management to any enterprise domain where autonomous agents need to act with real consequences: healthcare operations, industrial safety, financial operations, anywhere "the agent decided" isn't good enough and "here's cryptographic proof of what happened and why" is the actual requirement.

Built With

• docker
• ed25519
• fastapi
• framer-motion
• gemini
• google-adk
• google-cloud-firestore
• next.js
• opentelemetry
• pydantic
• pyjwt
• pytest
• python
• react
• render
• rest-api
• tailwindcss
• typescript
• vercel
• vertex-ai
• websockets