The Line Most Agentic Demos Get Wrong
There's a quietly important reference architecture in Google Cloud's contract-compliance-pipeline sample, and it's built on one sharp principle: LLMs are useful for ambiguity; deterministic agents should enforce hard policy.
That single sentence fixes the most common failure in enterprise AI. Most "AI compliance" demos let a language model both read the contract and decide whether it passes — which means the same document can pass on Monday and fail on Tuesday, and no auditor will ever accept "the model said so." The sample draws the line in the right place: use the LLM for the fuzzy part (pulling messy facts out of a document) and a deterministic service for the part that must be exact and reproducible (does this violate policy, yes or no).
How the Pipeline Works
It's a cross-language, two-service multi-agent system, and the design is worth understanding because it generalizes far beyond the demo:
- Python + ADK (orchestrator). A FastAPI service using Google's Agent Development Kit handles intake, extraction, and risk assessment — turning a raw contract into structured facts.
- A2A handoff. A
RemoteA2aAgentperforms an Agent2Agent handshake with the second service — discovering its capabilities via a published agent card (/.well-known/agent.json) and sending the extracted data as a JSON-RPC 2.0 message. - Go compliance agent (enforcer). A separate Go service validates the facts against configured thresholds — value caps, term limits, insurance minimums — with synchronous, repeatable checks. No LLM inference in this step.
- Auditable verdict. The Go service returns a structured pass/fail with the specific violations; the orchestrator renders a compliance certificate, and execution traces are logged.
Two Ideas Worth Stealing
1. The ambiguity / determinism split. This is the design principle behind trustworthy agentic systems. Anything that must be consistent, explainable, and auditable — a compliance verdict, a payment rule, an eligibility check — belongs in deterministic code, not in a model's head. The LLM's job is to handle the mess at the edges (reading varied document formats, resolving phrasing) and hand clean, structured data to the rule engine.
2. A2A as the interoperability layer. The Python and Go agents don't share a codebase — they speak a standard protocol (Agent2Agent over JSON-RPC, with discoverable agent cards). That means specialized agents can be written in the best language for the job, run as independent services, and be swapped or scaled without rewiring everything. It's the same reason microservices won: clean contracts between components.
Why This Lands in Real Estate
Real estate runs on contracts — leases, vendor agreements, purchase-and-sale, NDAs, insurance certificates — and every one of them carries hard rules that are perfect for deterministic enforcement:
- Lease compliance. LLM extracts term length, rent escalation, options, and liability clauses; a deterministic agent flags anything over a term cap, a missing insurance minimum, or a non-standard indemnity.
- Vendor & procurement. Auto-check that every contract meets your value thresholds, insurance requirements, and clause standards before signature — with a certificate that survives audit.
- Acquisition due diligence. Run a portfolio of agreements through the same pipeline and get a reproducible red-flag report, not a vibe.
- Auditability by design. Because policy lives in deterministic rules with logged traces, every verdict is explainable and repeatable — the thing regulated workflows actually require. It's the governance backbone we wrote about in the agentic orchestration layer and AI teammates.
The Honest Caveats
- Extraction is still the weak link. If the LLM mis-reads a clause, the deterministic checker faithfully enforces policy on wrong facts. Extraction needs its own evaluation and human review on low-confidence cases.
- It's a reference sample, not a product. The Google Cloud repo demonstrates the pattern (regex-based extraction, example thresholds); a production system needs robust extraction, your real policy library, and integration with your systems of record.
- Garbage policies, garbage verdicts. Deterministic enforcement is only as good as the rules you encode — the rule library becomes a maintained asset.
Frequently Asked Questions
What are ADK and A2A? ADK is Google's Agent Development Kit for building and orchestrating agents; A2A (Agent2Agent) is an open protocol that lets independent agents discover and message each other — here, a Python/ADK orchestrator hands off to a Go compliance agent over JSON-RPC.
Why not let the LLM decide compliance directly? Because compliance must be consistent, explainable, and auditable. An LLM can give different answers to the same input and can't be audited like code. The robust pattern uses the LLM for ambiguous extraction and a deterministic service for the pass/fail decision.
How does this apply to real estate? Lease, vendor, and purchase contracts carry hard rules (value caps, term limits, insurance minimums, required clauses) ideal for deterministic enforcement, with an LLM handling the messy extraction — producing auditable compliance certificates at portfolio scale.
The Takeaway
The lesson of this sample isn't a product — it's a discipline: let the model handle ambiguity, let deterministic agents enforce policy, and make them interoperate over open protocols. That's how you get agentic systems an auditor will actually trust. VSBD builds exactly this layer — extraction, deterministic policy enforcement, and the orchestration and audit trails around it — for real estate platforms. If contract compliance is a bottleneck in your operation, we can help you automate it without losing the audit trail.