FORGE (FLEET OPERATIONAL READINESS & GOVERNED EXECUTION)

Architecture

Inspiration The hardest part of restoring disabled fleet equipment is often not the repair itself. It is coordinating maintenance, approved parts, qualified labor, safety requirements, cyber screening, and human authority across operations that may last for weeks.

FORGE was inspired by my research into the Agentic Conway Effect: how explicit ownership, interface contracts, management structure, monitoring, and reserve capacity affect multi-agent performance. I built FORGE as a solo entrant to turn those principles into a working enterprise system—not another chatbot. All vehicles, procedures, personnel records, parts, and operational data in FORGE are synthetic. What FORGE does

FORGE (Fleet Operational Readiness & Governed Execution) coordinates the recovery of twelve fictional GX-12 ground-support vehicles. The demonstration begins with all twelve vehicles mission capable. When GX12-07 experiences a failed hydraulic actuator, FORGE: Drops fleet readiness from 12/12 to 11/12. Decomposes the discrepancy into exclusively owned work packages. Produces a grounded maintenance plan. Verifies approved parts, shipment status, and qualified personnel. Quarantines and screens an untrusted vendor bulletin containing a prompt-injection attempt. Enforces a binding Safety veto against an unauthorized substitute. Presents a complete evidence record for a human schedule-override decision. Persists the workflow across a simulated 21-day delay and resumes without re-initiation. Detects a failed Workforce agent and transfers ownership to a held reserve. Requests human approval before releasing the repaired equipment. Restores fleet readiness to 12/12 mission capable. The operator console shows fleet readiness, active workflows, human approval gates, agent status, live agent activity, injected anomalies, and a reconstructable audit trail.

How I built it FORGE uses a manager-and-specialist architecture: The Readiness Orchestrator decomposes work, assigns ownership, monitors execution, and deploys reserves. It performs no domain work. The Maintenance Agent creates grounded repair plans. The Supply Agent verifies approved parts and shipment facts. The Workforce Agent assigns only properly qualified personnel. The Safety & Policy Agent validates every proposed action and has a non-overridable veto. The Cyber Trust Agent quarantines and screens external documents before any other agent can access them.

All agent reasoning runs through Google ADK and Gemini 3.5 Flash on Vertex AI. Each role runs as an independently secured Cloud Run service with its own service account. Agents communicate through Pub/Sub using versioned JSON contracts validated at both publication and consumption.

Firestore stores workflow state, the logical clock, inbox/outbox records, agent registry, ownership claims, approval records, and the append-only audit trail. State changes, outputs, and audit events commit transactionally.

External documents follow a separate quarantine-first path using Cloud Storage, Model Armor, and an independent Gemini classifier. Raw document content never enters the agent bus. OpenTelemetry and Cloud Trace connect the complete workflow into a single distributed trace while deliberately excluding prompts, quarantined content, and raw chain-of-thought.

Challenges I faced The hardest challenges were distributed-systems problems rather than prompt-writing problems: Preventing duplicate work under Pub/Sub’s at-least-once delivery model. Ensuring Firestore transaction retries never repeat Gemini calls. Rejecting late results from agents that no longer own a work package. Transferring work atomically from a failed primary agent to its reserve. Preventing duplicate recoveries for the same vehicle under concurrent requests. Preserving quarantine integrity during failed or concurrent document ingestion. Deriving human identity exclusively from Google Cloud authentication rather than spoofable browser input.

Maintaining one trace across asynchronous services without exposing sensitive content. Testing against real Google emulators and deployed infrastructure repeatedly exposed behavior that local test doubles did not. Those findings became regression tests instead of undocumented limitations.

What I learned I learned that reliable agentic systems depend more on architecture than on the number of agents. Every model-asserted fact needs a trusted source of truth. Ownership must be enforced when results commit—not merely when work is assigned. Safety and cyber controls must be structural and fail closed. Human approval is most effective when reserved for consequential actions, while reversible coordination remains autonomous.

Most importantly, enterprise reasoning traces do not require exposing raw chain-of-thought. Structured decision records, audit events, and metadata-only distributed traces provide accountability without leaking prompts or sensitive content. Validation

The final candidate includes: 326 tests: 303 unit tests and 23 real-emulator integration tests. 10/10 consecutive successful live acceptance runs. A complete clean-project deployment from one command. Keyless deployment through GitHub Actions and Workload Identity Federation. Live IAM negative tests proving prohibited cross-role operations fail. A reconstructable Firestore audit trail. One end-to-end OpenTelemetry trace across the deployed agent fleet.

What is next The hackathon version intentionally focuses on one fully governed recovery at a time. Future work would add concurrent recoveries, real logistics and maintenance-system integrations, richer operational analytics, and deployment controls for production-regulated environments.