How to Build a customer support Agent Using AutoGen in Python for payments

A payments support agent handles the repetitive, high-volume questions that clog up your support queue: failed card charges, refund status, chargeback timelines, payment method updates, and transaction lookup requests. It matters because every bad answer in payments can become a compliance issue, a dispute, or a lost customer.

Architecture

• •User-facing assistant
  • •Receives the customer’s request and keeps the conversation focused on payment support.
• •Policy layer
  • •Blocks sensitive actions unless the request is allowed by your compliance rules.
• •Payment tools
  • •Functions for transaction lookup, refund status, dispute status, and payment method metadata.
• •AutoGen agents
  • •A AssistantAgent for reasoning and response drafting.
  • •A UserProxyAgent to execute tool calls and manage human-in-the-loop escalation.
• •Audit logger
  • •Stores prompts, tool calls, outputs, and escalation reasons for review.
• •Data boundary controls
  • •Keeps PII and payment data inside approved regions and systems.

Implementation

1. •

   Install AutoGen and define your payment tools

   Use real tools that talk to your internal systems. In payments, don’t let the model invent transaction states or refund outcomes.

from autogen import AssistantAgent, UserProxyAgent
from typing import Dict

# Example internal service wrappers
def lookup_transaction(transaction_id: str) -> Dict:
    # Replace with real API call to your payments ledger
    return {
        "transaction_id": transaction_id,
        "status": "failed",
        "reason": "insufficient_funds",
        "currency": "USD",
        "amount": 49.99,
    }

def get_refund_status(refund_id: str) -> Dict:
    # Replace with real API call to your refund service
    return {
        "refund_id": refund_id,
        "status": "pending",
        "eta_days": 3,
    }

def redact_payment_data(text: str) -> str:
    # Minimal example; use a proper DLP layer in production
    return text.replace("4111111111111111", "[REDACTED_CARD]")

2. •

   Create an assistant agent with tight instructions

   The assistant should explain payment issues clearly, ask for missing identifiers, and never expose raw PANs or internal risk signals.

system_message = """
You are a customer support agent for payments.
Rules:
- Only help with payment support topics: failed charges, refunds, disputes, card updates.
- Never request full card numbers or CVV.
- Ask for transaction_id or refund_id when needed.
- If the user asks for account changes or anything high-risk, escalate to a human.
- Do not fabricate statuses. Use tool results only.
- Keep responses concise and compliant.
"""

assistant = AssistantAgent(
    name="payments_support_assistant",
    system_message=system_message,
    llm_config={
        "model": "gpt-4o-mini",
        "temperature": 0,
    },
)

3. •

   Wire a user proxy agent to execute tools

   AutoGen’s UserProxyAgent can act as the execution layer. In this pattern, it runs deterministic Python functions and returns results to the assistant.

tool_registry = {
    "lookup_transaction": lookup_transaction,
    "get_refund_status": get_refund_status,
}

user_proxy = UserProxyAgent(
    name="tool_executor",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=3,
)

def run_payment_support(user_text: str):
    cleaned = redact_payment_data(user_text)

    chat_result = user_proxy.initiate_chat(
        assistant,
        message=cleaned,
        clear_history=True,
    )
    return chat_result

4. •

   Use function calling for controlled payment lookups

   For production support flows, define explicit tool schemas and let the assistant choose from approved actions only. This keeps the agent inside a narrow blast radius.

from autogen import ConversableAgent

payment_agent = ConversableAgent(
    name="payment_agent",
    system_message=system_message,
    llm_config={"model": "gpt-4o-mini", "temperature": 0},
)

# Register callable tools on the agent
payment_agent.register_for_llm(name="lookup_transaction", description="Look up a payment transaction")(lookup_transaction)
payment_agent.register_for_llm(name="get_refund_status", description="Check refund status")(get_refund_status)

user_proxy.register_for_execution(name="lookup_transaction")(lookup_transaction)
user_proxy.register_for_execution(name="get_refund_status")(get_refund_status)

Production Considerations

• •Compliance first
  • •Enforce PCI DSS boundaries. The agent should never accept CVV, full PAN storage, or free-form card data in logs.
• •Auditability
  • •Log every prompt, tool call, response, and escalation decision with immutable timestamps and correlation IDs.
• •Data residency
  • •Keep model calls and retrieved payment records inside approved regions. If your policy says EU data stays in EU infrastructure, enforce that at the routing layer.
• •Human escalation
  • •Route disputes involving chargebacks, fraud claims, account closure requests, or legal threats to a human agent immediately.

Common Pitfalls

1. •

   Letting the model guess payment state

   • •Bad pattern: “It looks like your refund was completed.”
   • •Fix: always read from authoritative systems like ledger APIs or refund services.
2. •

   Passing raw sensitive data into prompts

   • •Bad pattern: sending full card numbers, CVV, or unredacted bank details to the model.
   • •Fix: redact before inference and use tokenized identifiers like transaction_id, refund_id, or masked last-four values.
3. •

   Skipping escalation rules

   • •Bad pattern: letting the agent handle disputes or fraud allegations end-to-end.
   • •Fix: define hard triggers for human review when the request touches chargebacks, KYC/AML concerns, sanctions screening, or account takeover risk.
4. •

   Ignoring regional controls

   • •Bad pattern: sending EU customer data to a US-hosted model endpoint without review.
   • •Fix: pin deployment regions and verify vendor contracts match your residency obligations before going live.

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.