EnterpriseDealPilot: Governed Quote-to-Close Agents

• 

• 

Inspiration

Enterprise sales processes remain fragmented across CRM, email, product catalogues, pricing engines, document repositories, and approval systems. Salespeople spend substantial time reconstructing customer context, resolving missing data, coordinating specialists, and manually updating systems. Conventional copilots generate content but rarely complete the governed workflow.

What it does

EnterpriseDealPilot uses Google's Gemini AI to run a team of specialized sales agents:

A lead agent walks the salesperson through the whole deal, start to finish It asks for anything missing, then hands off pricing, risk-checking, and proposal-writing to specialist agents built for each job Nothing moves forward until every check passes — including a required pause for a human to approve any large discount It remembers what a customer has already confirmed, so it doesn't ask the same question twice in a later conversation — though it always double-checks the old answer is still accurate before relying on it Every backend service is locked down: nothing is open to the public, and each one only talks to the specific other services it's allowed to Every message the system generates is checked before it's used, and every request leaves a trail we can search afterward

How we built it

The AI team

One lead agent — the "Deal Orchestrator" — manages the whole conversation with the salesperson, from start to finish It's powered by Google's Gemini AI (specifically Gemini 3.6 Flash), running on Google Cloud rather than a free/limited tier It hands off three specific jobs to three specialist agents: pricing, risk-and-approval checking, and proposal-writing Each specialist works in its own separate conversation — it can't see what another specialist discussed, only what the lead agent tells it

The six worker programs

Six small, independent programs do the actual work, each running as its own separate service in the cloud Salesforce service — the only one allowed to read or write customer records Pricing service — calculates prices and digitally signs them, so a price can't be faked or silently changed Approval service — holds a discount request until a real person signs off on it Documents service — writes the sales proposal and double-checks it hasn't been tampered with before saving it Security service — scans everything for malicious or fake instructions before it's used (real Google Model Armor, not a mockup) Communication service — only sends an email once a specific person has been approved to receive it All six can run on made-up test data (for safe demos) or a real Salesforce account, without changing any code

Keeping it safe and trustworthy

No number the AI generates is ever trusted blindly — prices are digitally signed and double-checked, and proposals are checked for tampering before they're saved A large discount always pauses the process until a real person approves it — the AI can never approve its own discount Every one of the six services has its own separate login — nothing is open to the public internet, and each service only talks to the specific other services it's allowed to

Remembering customers

Uses real Google Memory Bank — not a workaround — to remember a customer's confirmed details (like "budget approved" or "needs EU data residency") between separate conversations It never just assumes a remembered fact is still true — it brings it up and asks the seller to confirm it's still accurate before moving on Tested for real: a fact confirmed in one conversation showed up correctly in a brand-new one afterward, even after fully restarting the system in between

Where it runs, and how we can check on it

All six services — plus the demo website itself — are live on Google Cloud right now, not just running on a laptop Every service registers itself in a central directory, so it's easy to see what exists and where Every request gets a shared tracking number, so we can pull up everything that happened for one conversation in a single search

The whole thing is also live as a public website anyone can open and try — not a video, not a screenshot

Challenges we ran into

--- Our price-locking system was very strict about exactly how a number had to be written down When Gemini generated a price, it wrote the number slightly differently than expected (9600 instead of 9600.0). A completely legitimate, unedited price got flagged as fake, purely because of that tiny formatting difference. We made the price-checking ignore that kind of harmless difference

--- Our proposal-writing agent only ever heard about a price second-hand, as a sentence from another agent — never the real numbers directly. Instead of relying on what it was told, the agent now looks the numbers up itself, directly at the source.

--- One service tried to call another while it was already busy handling a different request, and our code wasn't ready for that exact situation. Handled that specific case properly, and re-tested against the real, live services.

Accomplishments that we're proud of

We tested everything for real --- Every part of this was tested for real — using an actual Salesforce account, Google's real security scanner, real Gemini AI, and real cloud servers, not just tests running on a laptop.

--- The security demo is real: we planted a fake malicious instruction in test data, and the system caught it, blocked it, and never acted on it — checked against the exact attack text, not a made-up pass/fail.

--- No step can be skipped: a price must be signed and verified, a big discount must be approved by a real person, and nothing gets emailed without permission tied to that exact recipient.

--- All six backend services are locked down individually — nothing is open to the internet, and each one only trusts the specific other services it needs to.

--- Every request gets a shared tracking number, so we can find everything that happened for one conversation in a single search.

--- Anyone can try the real, live product right now — it's a working website, not a video or a set of screenshots.

--- The system now remembers a customer's confirmed details across separate conversations, using real Google Memory Bank — tested for real: a fact confirmed in one conversation was correctly recalled days later in a brand-new one.

What we learned

--- AI can accidentally change a number just by rewriting it. So never trust a number an AI has touched — always double-check it independently before acting on it.

--- Don't ask one AI agent to retype details from memory. If it needs information another agent has, have it look that information up directly instead of relying on a secondhand summary.

--- Testing against real systems finds real problems that fake test data hides completely. It's more work upfront, but it's worth it every time.

What's next for EnterpriseDealPilot: Governed Quote-to-Close Agents

--- Actually sending real emails, plus a way to automatically reset the demo data between test runs.

--- A real security checkpoint in front of every service. Right now our AI agents run inside one program, not as their own separate services — turning them into standalone services is the real path to a fully policed system, and it's a bigger project on its own.

--- A real approval system. Right now, "waiting for approval" is simulated with a direct call inside our own code. We want a real notification that a human can act on from anywhere, not just from inside this one program.

Built With

• apex
• fastapi
• fastmcp
• gemini
• google-agent-registry
• google-cloud-build
• google-cloud-iam
• google-cloud-logging-salesforce:-salesforce
• google-cloud-model-armor
• google-cloud-run
• hmac
• javascript-ai/google-cloud:-google-agent-development-kit-(adk)
• languages/core:-python
• ngrok
• salesforce-apex
• salesforce-dx-(sfdx)
• salesforce-lightning-web-components-(lwc)
• simple-salesforce-protocol/backend:-model-context-protocol-(mcp)
• uvicorn-infra/tooling:-docker
• vertex-ai
• vertex-ai-memory-bank