What is prompt engineering in AI Agents? A Guide for developers in wealth management

Prompt engineering is the practice of writing instructions for an AI model so it produces the output you want. In AI agents, prompt engineering is how you control the agent’s role, scope, tools, constraints, and response format.

How It Works

Think of a prompt like a trade ticket for an AI agent.

A vague ticket says: “Handle this client request.”
A good ticket says: “You are a wealth management service agent. Check portfolio exposure, compare against risk profile, flag concentration risk above 20%, and respond in JSON with risk_level, summary, and next_action.”

That difference matters because an AI agent is not just generating text. It is often deciding whether to call tools, retrieve documents, summarize data, or escalate to a human advisor.

In practice, prompt engineering gives the agent four things:

• •Role: who it should act as
• •Task: what it must do
• •Constraints: what it must not do
• •Format: how the answer should be structured

For wealth management systems, this is similar to defining operating procedures for a junior analyst. The analyst might know finance, but without clear instructions they may over-explain, miss compliance rules, or return data in a format your downstream system cannot use.

A useful mental model is a client meeting agenda:

• •If the agenda is loose, the meeting drifts.
• •If the agenda is precise, everyone knows what to prepare, when to speak, and what decisions need approval.

Prompt engineering does the same thing for agents.

A simple pattern

A production prompt usually contains:

• •System instructions: permanent behavior rules
• •Task instructions: what to do for this request
• •Context: client profile, holdings, policy docs, market data
• •Output schema: exact structure for machine consumption

Example skeleton:

You are an assistant for a wealth management platform.
Only answer using approved client data and policy documents.
If required data is missing, ask one clarifying question.
Return output as valid JSON with:
- recommendation
- rationale
- compliance_flags
- escalation_needed

That last part matters. If your agent feeds another workflow step or case management system, free-form prose becomes technical debt fast.

Why It Matters

Developers in wealth management should care because prompt quality directly affects product behavior.

• •

  Compliance risk

  • •Bad prompts can cause hallucinated advice, unsupported recommendations, or missing disclaimers.
  • •In regulated environments, “close enough” is not good enough.
• •

  Operational reliability

  • •Agents need predictable outputs for routing cases, drafting responses, or summarizing accounts.
  • •Structured prompts reduce brittle downstream parsing and manual cleanup.
• •

  User trust

  • •Wealth clients expect precision.
  • •A vague or overly confident answer can damage confidence faster than a failed API call.
• •

  Tool usage

  • •Agents often need to query CRM systems, portfolio services, KYC records, or document stores.
  • •Prompt engineering determines when the agent should use tools versus answer from context alone.

Real Example

Let’s say you are building an internal assistant for relationship managers at a private bank.

The goal: help staff answer a client question about portfolio concentration risk without giving unauthorized investment advice.

Bad prompt

Explain whether this portfolio looks risky.

This is too open-ended. The model may invent thresholds, ignore policy rules, or produce advice that sounds like a recommendation.

Better prompt

You are an internal assistant for relationship managers at a private bank.

Task:
Review the client's portfolio summary and identify concentration risk only.
Do not recommend trades or asset allocation changes.

Rules:
- Use only the provided holdings and client risk profile.
- Flag concentration risk if any single position exceeds 15% of portfolio value.
- If data is incomplete, set "escalation_needed" to true.
- Do not mention performance forecasts or market opinions.

Output format:
Return valid JSON with these fields:
{
  "concentration_risk": "low|medium|high",
  "flags": [],
  "summary": "",
  "escalation_needed": true|false
}

Why this works

This prompt does several things well:

• •It narrows the task to one decision: concentration risk.
• •It sets a measurable rule: anything above 15%.
• •It blocks unsafe behavior: no trades, no forecasts.
• •It forces machine-readable output.

Example output

{
  "concentration_risk": "high",
  "flags": [
    "AAPL position = 22% of portfolio value"
  ],
  "summary": "Portfolio has one position above the allowed concentration threshold.",
  "escalation_needed": true
}

That output can now drive workflow logic:

• •Create a case for advisor review
• •Notify compliance if needed
• •Populate CRM notes automatically

For insurance teams building similar agents, the same pattern applies. A claims triage agent might be prompted to classify severity based on policy text and claim metadata while refusing to estimate payout amounts unless explicitly authorized by business rules.

Related Concepts

These topics sit close to prompt engineering and show up quickly in real agent systems:

• •

  System prompts

  • •Persistent instructions that define agent behavior across requests.
• •

  RAG (Retrieval-Augmented Generation)

  • •Pulling policy docs, product terms, or account data into context before generating an answer.
• •

  Tool calling

  • •Letting the agent query APIs instead of guessing from memory.
• •

  Structured outputs

  • •Forcing JSON or schema-based responses so downstream services can consume them reliably.
• •

  Guardrails

  • •Validation layers that block unsafe content, enforce policy rules, and catch malformed outputs before they reach users.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.