ISRS — Individual Structured Revenue System

ISRS turns raw business signals into verified revenue intelligence through a Google-native eight-agent fleet, producing command-ready briefs while keeping final authority with the human Lead Commander

Comment

Inspiration

ISRS — Individual Structured Revenue System — was inspired by a real operator problem: ideas, attention, conversations, referrals, DMs, and leads appear every day, but they do not automatically become structured revenue.

Small businesses and independent operators often do not lose opportunities because they lack interest. They lose them because the signal is incomplete, scattered, misunderstood, delayed, or never converted into a clear decision.

I wanted to build something that does more than answer a prompt.

The goal became a governed command system that can understand a business signal, qualify what matters, preserve accepted truth, identify missing information, assess risk and opportunity, synthesize specialist intelligence, verify the result, and still leave the final operational decision with a human.

The visual language and some workflow concepts were inspired by prior JuliusSlaughter.io Command Core work: a dark mission-control environment, signal-driven interaction, command surfaces, and a human-review mindset. Lead Command Agent itself is a fresh Google-native hackathon implementation built around Gemini, Google Cloud, persistent evidence, and bounded multi-agent orchestration.

What it does

ISRS turns raw business signals into structured, verified revenue intelligence.

The working implementation is Lead Command Agent.

A visitor can begin with an idea, lead, referral, conversation, DM, or opportunity. The public CQA — Command Qualifying Agent interprets the signal, asks only the next useful qualification question, and builds a Personal GenAI Brief from accepted evidence.

The visitor can confirm or correct that Brief. Material missing details remain explicit instead of being invented. After contact and consent are completed, the opportunity becomes a verified submission.

That submission is persisted to Cloud Firestore and triggers the agent fleet through Eventarc.

The system then routes the opportunity through a fixed eight-agent architecture:

  1. Conductor Agent — owns runtime routing and orchestration
  2. CQA — contributes qualification intelligence
  3. Memory Agent — evaluates authorized prior context when available
  4. Risk Agent — assesses uncertainty and risk boundaries
  5. Opportunity Agent — evaluates evidence-backed commercial potential
  6. Follow-Up Agent — forms bounded next-step guidance
  7. CCA — synthesizes the internal Command Brief
  8. Verifier Agent — independently checks the Brief before presentation

The output is not simply another chatbot answer.

It is a Verified Command Brief containing evidence-backed qualification, risk, opportunity intelligence, missing information, recommended attention, agent lineage, and the Verifier gate.

That Brief is presented inside the private Command Office, where the Lead Commander retains final authority.

Agents advise. Verifier checks. Lead Commander decides.

How we built it

ISRS was built as a Google-native, production-style agentic system with explicit separation between model intelligence and business-state authority.

The deployed stack includes:

  • Gemini 3.5 Flash for natural-language interpretation and bounded agent intelligence
  • Google GenAI SDK as the Gemini integration layer
  • Google Cloud Run for the hosted FastAPI runtime and agent execution service
  • Cloud Firestore for canonical state, Personal Brief lineage, submissions, AgentRuns, AgentEvents, Command Briefs, and read-back proof
  • Eventarc to trigger asynchronous fleet execution from verified Firestore submissions
  • Secret Manager for the Gemini credential and private Command Office operator credential
  • Cloud Build / Artifact Registry for the container build and deployment path
  • Python / FastAPI for the server runtime
  • HTML, CSS, and JavaScript for the public CQA experience and private Lead Commander interface

A major architectural decision was that Gemini does not own canonical truth.

The model can interpret language and contribute intelligence, but accepted visitor facts are controlled by server-owned state. Visitor corrections outrank inference. Unresolved facts remain unresolved. Commercial fields such as opportunity value, cost of no change, investment, revenue, and timeline remain separate instead of overwriting one another.

The same authority discipline continues through the agent fleet:

  • the Conductor owns routing;
  • specialist agents cannot self-route;
  • CCA can synthesize but cannot approve;
  • the Verifier independently gates the final Brief;
  • the Lead Commander retains final operational control.

The system also persists the decision path rather than only the final response. Agent events, run state, evidence, corrections, Command Brief formation, and Lead Commander state can be inspected after execution.

Challenges we ran into

The hardest challenge was preventing the project from becoming agent theater.

It is easy to display eight agent names on a screen. It is much harder to make those agents operate inside real authority boundaries, persist their contributions, maintain evidence lineage, survive retries and state transitions, and prevent one agent from silently taking authority that belongs somewhere else.

A second challenge was truth ownership.

Natural-language models are useful because they can interpret messy business conversations, but that same flexibility becomes dangerous if model output is allowed to overwrite accepted business facts. We had to separate semantic intelligence from canonical state so the model could help without becoming the source of truth.

A third challenge was orchestration and verification.

The Conductor needed to remain the sole route controller while CQA, Memory, Risk, Opportunity, Follow-Up, CCA, and Verifier remained bounded specialists. CCA also could not be allowed to approve its own synthesis, so the Verifier became an independent presentation gate.

Persistence introduced another layer of complexity. Qualification state, corrections, Brief versions, submissions, agent runs, events, retries, and Lead Commander decisions all needed stable identities and durable lineage.

Finally, we had to make the Google integration visible without turning the demo into infrastructure theater. The deployed system therefore exposes live runtime and persistence proof while keeping secrets and administrative authority off the browser.

Accomplishments that we're proud of

The biggest accomplishment is that Lead Command Agent became a working end-to-end system, not just a concept or interface.

The final submission includes:

  • a deployed public CQA experience;
  • adaptive qualification powered by Gemini;
  • a visitor-confirmed Personal GenAI Brief;
  • correction precedence and explicit Missing Details;
  • server-owned canonical truth;
  • verified review submission;
  • Cloud Firestore persistence;
  • Eventarc-triggered asynchronous orchestration;
  • a bounded eight-agent fleet;
  • persisted AgentRuns and AgentEvents;
  • evidence-backed Opportunity, Risk, and Follow-Up intelligence;
  • CCA Command Brief synthesis;
  • an independent Verifier gate;
  • a private Lead Commander Command Office;
  • opportunity review and persisted Lead Commander state;
  • observable agent lineage for judges;
  • live Google Cloud runtime/read-back proof;
  • reproducible local and Cloud Run setup instructions;
  • a clean public GitHub submission repository.

The final automated validation suite contains 543 passing tests covering state authority, qualification behavior, persistence, security, orchestration, agent contracts, Brief formation, Verifier gating, operator workflows, frontend contracts, and runtime behavior.

We are especially proud that the architecture maintains a simple rule throughout the entire system:

AI organizes. Evidence stays visible. Humans control action.

What we learned

The biggest lesson was that a serious agentic system is not simply a collection of LLM calls.

Real orchestration requires:

  • explicit authority boundaries;
  • durable state;
  • evidence-linked decisions;
  • correction precedence;
  • bounded model permissions;
  • stable identities and lineage;
  • asynchronous execution discipline;
  • idempotency and retry awareness;
  • independent verification;
  • human-in-the-loop control;
  • observable runtime proof.

We also learned that the model should not own everything.

Gemini is extremely valuable for interpreting natural language and contributing bounded intelligence, but deterministic business rules and server-owned state are better suited for protecting accepted truth and governance.

The combination is stronger than either one alone.

Another lesson was that observability matters. A judge, operator, or future administrator should be able to understand not just what the system decided, but which agents contributed, what evidence they used, what was unresolved, what the Verifier allowed, and where human authority begins.

What's next for ISRS

The next stage is expanding the system beyond a single revenue-intelligence workflow while preserving the same governance model.

Potential directions include:

  • additional authorized business-data connectors;
  • richer persistent memory with explicit eligibility and consent rules;
  • multilingual qualification;
  • configurable opportunity and risk policies for different industries;
  • broader operator analytics and portfolio intelligence;
  • additional bounded specialist agents where they provide measurable value;
  • stronger production monitoring and operational telemetry;
  • organization-level deployment while preserving human approval boundaries.

The long-term vision is for ISRS — Individual Structured Revenue System to become a command layer for independent operators and small businesses that need the benefits of sophisticated AI and revenue operations without needing a Fortune 500 technology department.

The principle remains the same:

Turn business signals into structured revenue intelligence without surrendering truth, evidence, or human control.

Built With

Share this project:

Updates

Submission history