How to Integrate OpenAI for banking with AWS Lambda for multi-agent systems

Integrating OpenAI for banking with AWS Lambda gives you a clean way to run regulated AI workflows without standing up always-on infrastructure. For multi-agent systems, this is the pattern that matters: one agent classifies the request, another retrieves context, and Lambda handles orchestration, retries, and event-driven execution.

Prerequisites

• •Python 3.10+
• •AWS account with:
  • •Lambda enabled
  • •IAM role for Lambda execution
  • •CloudWatch Logs access
• •AWS CLI configured locally:
  • •aws configure
• •OpenAI API key stored in AWS Secrets Manager or environment variables
• •boto3 installed:
  • •pip install boto3
• •openai Python SDK installed:
  • •pip install openai
• •A basic understanding of:
  • •AWS Lambda handlers
  • •JSON event payloads
  • •Multi-agent orchestration patterns

Integration Steps

1. •Set up your Lambda handler to receive agent tasks.

For multi-agent systems, each Lambda invocation should represent one bounded task. Keep the handler thin: parse input, call OpenAI for banking, return structured JSON.

import json
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def lambda_handler(event, context):
    user_message = event.get("message", "")
    system_prompt = (
        "You are a banking assistant. "
        "Classify the request into one of: balance_check, payment_dispute, "
        "loan_query, fraud_alert, or general_support. "
        "Return JSON with keys: category, confidence, summary."
    )

    response = client.responses.create(
        model="gpt-4.1-mini",
        input=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message}
        ],
        response_format={"type": "json_object"}
    )

    return {
        "statusCode": 200,
        "body": response.output_text
    }

2. •Store secrets in AWS and load them inside Lambda.

Do not hardcode API keys in code. Use AWS Secrets Manager for production and inject only the secret name into the function environment.

import json
import os
import boto3
from openai import OpenAI

secrets_client = boto3.client("secretsmanager")

def get_secret(secret_name: str) -> dict:
    secret_value = secrets_client.get_secret_value(SecretId=secret_name)
    return json.loads(secret_value["SecretString"])

def build_openai_client():
    secret_name = os.environ["OPENAI_SECRET_NAME"]
    secret_data = get_secret(secret_name)
    return OpenAI(api_key=secret_data["OPENAI_API_KEY"])

def lambda_handler(event, context):
    client = build_openai_client()
    prompt = event["message"]

    result = client.responses.create(
        model="gpt-4.1-mini",
        input=prompt
    )

    return {
        "statusCode": 200,
        "body": result.output_text
    }

3. •Add agent routing logic for multi-agent orchestration.

A banking workflow usually needs routing before generation. One agent classifies intent; another handles summarization; a third can trigger downstream tools like case management or CRM updates.

import json
from openai import OpenAI

client = OpenAI()

ROUTES = {
    "balance_check": "balance_agent",
    "payment_dispute": "dispute_agent",
    "loan_query": "loan_agent",
    "fraud_alert": "fraud_agent",
    "general_support": "support_agent"
}

def route_request(message: str) -> str:
    resp = client.responses.create(
        model="gpt-4.1-mini",
        input=[
            {"role": "system", "content": (
                "Classify the banking request into one label only: "
                "balance_check, payment_dispute, loan_query, fraud_alert, general_support."
            )},
            {"role": "user", "content": message}
        ],
        response_format={"type": "json_object"}
    )

    data = json.loads(resp.output_text)
    return ROUTES.get(data["category"], "support_agent")

def lambda_handler(event, context):
    message = event["message"]
    target_agent = route_request(message)

    return {
        "statusCode": 200,
        "body": json.dumps({
            "target_agent": target_agent,
            "message": message
        })
    }

4. •Invoke downstream Lambdas from the orchestrator.

This is where AWS Lambda becomes the backbone of your multi-agent system. One function can call other functions using boto3.client("lambda").invoke(...), which keeps each agent isolated and independently deployable.

import json
import boto3

lambda_client = boto3.client("lambda")

def invoke_agent(function_name: str, payload: dict) -> dict:
    response = lambda_client.invoke(
        FunctionName=function_name,
        InvocationType="RequestResponse",
        Payload=json.dumps(payload).encode("utf-8")
    )
    body = response["Payload"].read().decode("utf-8")
    return json.loads(body)

def lambda_handler(event, context):
    route = event["target_agent"]

    if route == "fraud_agent":
      result = invoke_agent(
          function_name="fraud-agent-lambda",
          payload={"message": event["message"]}
      )
      return result

    if route == "loan_agent":
      result = invoke_agent(
          function_name="loan-agent-lambda",
          payload={"message": event["message"]}
      )
      return result

    return invoke_agent(
        function_name="support-agent-lambda",
        payload={"message": event["message"]}
    )

5. •Return structured outputs that downstream systems can consume.

Banking workflows need deterministic output. Don’t return raw prose when another service expects fields like case type, risk score, or escalation status.

from openai import OpenAI

client = OpenAI()

def lambda_handler(event, context):
    message = event["message"]

    response = client.responses.create(
        model="gpt-4.1-mini",
        input=[
            {"role": "system", "content": (
                "Extract structured data from banking support text. "
                "Return JSON with fields: customer_intent, urgency_level, "
                "requires_human_review (true/false), short_summary."
            )},
            {"role": "user", "content": message}
        ],
        response_format={"type":"json_object"}
    )

    return {
        "statusCode": 200,
        "headers": {"Content-Type": "application/json"},
        "body": response.output_text
    }

Testing the Integration

Use a local test event first if you’re deploying through SAM or direct Lambda uploads. The goal is to verify both the OpenAI call and the Lambda invocation path.

import json

test_event = {
    "message": "A customer says they were charged twice for card payment on Friday."
}

# Simulate local invocation of your handler
result = lambda_handler(test_event, None)
print(result)
print(json.loads(result["body"]))

Expected output:

{
  "statusCode": 200,
  "body": "{\"customer_intent\": \"payment_dispute\", \"urgency_level\": \"high\", \"requires_human_review\": true, \"short_summary\": \"Customer reports duplicate card charge on Friday.\"}"
}

If you are testing the downstream Lambda call directly:

import json
import boto3

client = boto3.client("lambda")

response = client.invoke(
    FunctionName="support-agent-lambda",
    InvocationType="RequestResponse",
    Payload=json.dumps({"message": test_event["message"]}).encode("utf-8")
)

print(response["StatusCode"])
print(response["Payload"].read().decode("utf-8"))

Real-World Use Cases

• •

  Fraud triage pipeline:

  • •One agent detects suspicious language or transaction patterns.
  • •Another agent summarizes evidence.
  • •Lambda routes high-risk cases to a human queue or SIEM integration.
• •

  Customer support orchestration:

  • •An intake agent classifies requests.
  • •A product-specific agent answers checking-account or loan questions.
  • •A compliance agent reviews responses before release.
• •

  Document processing for banking ops:

  • •One Lambda handles OCR/document ingestion.
  • •OpenAI extracts entities from statements or forms.
  • •A follow-up Lambda writes structured records into DynamoDB or a case system.

This setup scales because each part has one job. OpenAI handles reasoning and extraction; AWS Lambda handles execution and routing; your multi-agent layer stays modular enough to evolve without rewriting the whole stack.

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.