Agentic AI Assistant for Wealth Advisors

A wealth advisor’s knowledge is spread across systems that were never designed to be read together: a CRM for relationships, a portfolio system for holdings, a research platform for market views, a planning tool for goals, and a folder of PDFs for everything the enterprise says about its own products. Answering one client question means visiting several of them, correlating by hand, and remembering which answer came from where.

That is a retrieval problem on the surface and a synthesis problem underneath. A search box across all five systems still leaves the advisor to reconcile the results. The agentic version reasons over what came back, asks a follow-up when the request is ambiguous, and hands over an answer that has already been checked for compliance.

How it works

The orchestrator is an ADK LlmAgent whose tools are other agents. Routing is therefore a model decision at runtime rather than a fixed graph, which is what lets one advisor question fan out to the CRM and the document index while the next needs neither:

def create_financial_advisor_agent() -> Agent:
    """Knowledge orchestrator: sub-agents exposed to the model as tools."""
    return LlmAgent(
        name="financial_advisor_agent",
        model=Gemini(model=settings.vertex_ai_model, retry_options=retry_config),
        description=(
            "guide advisors through a structured process to their financial "
            "queries by orchestrating a series of expert subagents"
        ),
        tools=[
            AgentTool(agent=financial_enterprise_docs_agent),
            AgentTool(agent=google_research_agent),
            AgentTool(agent=crm_leads_insights_agent),
            AgentTool(agent=compliance_checker_agent),
        ],
        instruction=FINANCIAL_ADVISOR_PROMPT,
        output_key="financial_advisor_output",
    )

Each specialist owns its own tools and — importantly — its own model choice. The compliance check does not need the same model as open-ended research, and splitting them is what makes the cost and latency of each hop tunable:

compliance_checker_agent = LlmAgent(
    name="compliance_checker_agent",
    model=Gemini(model=settings.vertex_ai_compliance_model, retry_options=retry_config),
    description="ensures responses are complete, accurate and compliant, including AI disclosure",
    instruction=COMPLIANCE_CHECKER_AGENT_PROMPT,
    tools=compliance_tools,
)

crm_leads_insights_agent = LlmAgent(
    name="crm_leads_insights_agent",
    model=Gemini(model=settings.vertex_ai_model, retry_options=retry_config),
    description="Insights agent for CRM leads and prospects",
    instruction=CRM_LEADS_INSIGHTS_AGENT_PROMPT,
    tools=[FunctionTool(func=crm_dataframe_tool.query_dataframe)],
)

Adding a system means adding an agent and its tools, not rewriting the orchestrator. Portfolio management (Envestnet, Yodlee), research (Morningstar, Yahoo Finance) and financial planning (eMoney, RightCapital, MoneyGuidePro) all extend the same shape.

What to get right

• Make compliance a hop, not a prompt instruction. A separate agent with its own model and tools produces an artifact you can log and audit. A paragraph in the orchestrator’s system prompt produces nothing you can show a regulator.
• Keep public research in its own agent. Search results are untrusted content. Merging them into the same context as client data, with no boundary, is how prompt injection reaches a CRM tool.
• Persist sessions outside the process. Advisor conversations span a working day and survive deploys. Agent Engine Sessions and Memory Bank make that the platform’s problem rather than a sticky-session workaround.
• Trajectory beats output-only evaluation. ADK eval scores which tools were called in what order, which catches the failure that matters here: a plausible answer assembled from the wrong system.
• Budget the fan-out. Every AgentTool call is another model round trip. Cap steps, tokens and wall-clock time per request, or one ambiguous question becomes an unbounded bill.

The reference implementation is on GitHub and continues to be extended; the design rationale is written up in more depth in this article on Medium.