How to Integrate OpenAI for pension funds with AWS Lambda for AI agents

Combining OpenAI with AWS Lambda gives you a clean pattern for pension-fund AI agents: let Lambda handle event-driven execution, policy checks, and secure orchestration, while OpenAI handles language understanding, summarization, and response generation. That means you can build agents that triage member queries, summarize retirement documents, or draft advisor notes without running a long-lived service.

Prerequisites

• •Python 3.10+
• •AWS account with:
  • •IAM role for Lambda execution
  • •CloudWatch Logs permissions
• •AWS CLI configured locally:
  • •aws configure
• •OpenAI API key stored in AWS Secrets Manager or as a Lambda environment variable
• •boto3 installed locally for testing
• •openai Python SDK installed
• •A deployed AWS Lambda function or permission to create one
• •Basic knowledge of:
  • •IAM policies
  • •Lambda handler structure
  • •JSON event payloads

Install the Python dependencies:

pip install openai boto3

Integration Steps

1. •Set up your OpenAI client and Lambda caller.

Use the modern OpenAI SDK and boto3 Lambda client in the same project. Keep the OpenAI key outside code, and use AWS credentials from the environment or IAM role.

import os
import json
import boto3
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
lambda_client = boto3.client("lambda", region_name=os.environ.get("AWS_REGION", "us-east-1"))

2. •Build the Lambda function that receives pension-fund events.

This function can accept a member question, call OpenAI, and return a structured answer. In production, keep the prompt narrow and force JSON output if downstream systems need it.

import json
from openai import OpenAI

client = OpenAI()

def lambda_handler(event, context):
    member_query = event.get("query", "")
    member_id = event.get("member_id", "unknown")

    prompt = f"""
You are a pension fund support assistant.
Answer only using general retirement guidance.
If the question needs human review, say so.

Member ID: {member_id}
Question: {member_query}
"""

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

    answer_text = response.output_text

    return {
        "statusCode": 200,
        "body": json.dumps({
            "member_id": member_id,
            "answer": answer_text,
        }),
    }

3. •Invoke the Lambda function from your AI agent orchestrator.

Your agent can decide when to call Lambda for controlled execution. This is useful when you want one tool to handle regulated workflows and another to handle reasoning.

import json
import boto3

lambda_client = boto3.client("lambda", region_name="us-east-1")

payload = {
    "member_id": "PF-100245",
    "query": "Can I withdraw part of my pension before retirement age?"
}

response = lambda_client.invoke(
    FunctionName="pension-fund-agent-handler",
    InvocationType="RequestResponse",
    Payload=json.dumps(payload).encode("utf-8"),
)

result = json.loads(response["Payload"].read().decode("utf-8"))
print(result["body"])

4. •Add a second OpenAI call inside your agent for post-processing.

A common pattern is: Lambda generates the raw answer, then your orchestration layer asks OpenAI to rewrite it into a more formal advisor note or classify urgency.

import os
import json
import boto3
from openai import OpenAI

openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
lambda_client = boto3.client("lambda", region_name="us-east-1")

def summarize_for_advisor(member_question: str) -> str:
    resp = openai_client.responses.create(
        model="gpt-4.1-mini",
        input=f"Rewrite this pension query as an internal advisor note:\n{member_question}"
    )
    return resp.output_text

payload = {
    "member_id": "PF-100245",
    "query": "I changed jobs twice last year. Where did my contributions go?"
}

lambda_resp = lambda_client.invoke(
    FunctionName="pension-fund-agent-handler",
    InvocationType="RequestResponse",
    Payload=json.dumps(payload).encode("utf-8"),
)

body = json.loads(lambda_resp["Payload"].read().decode("utf-8"))["body"]
advisor_note = summarize_for_advisor(body)
print(advisor_note)

5. •Harden the integration for production.

For pension workflows, don’t pass raw PII into prompts unless you have a clear legal basis and data handling policy. Use redaction before calling OpenAI, log only correlation IDs in CloudWatch, and keep business rules in code rather than in prompts.

import re

def redact_pii(text: str) -> str:
    text = re.sub(r"\b\d{13}\b", "[NATIONAL_ID]", text)
    text = re.sub(r"\b\d{10}\b", "[PHONE]", text)
    text = re.sub(r"[A-Z]{2}\d{6}[A-Z]\b", "[MEMBER_REF]", text)
    return text

safe_query = redact_pii("My member ref PF123456 and phone 0712345678 need help.")
print(safe_query)

Testing the Integration

Run a local smoke test against Lambda if you have AWS credentials configured. This verifies both the invocation path and the model response path.

import json
import boto3

lambda_client = boto3.client("lambda", region_name="us-east-1")

test_event = {
    "member_id": "PF-TEST-001",
    "query": "What happens to my pension if I retire early?"
}

response = lambda_client.invoke(
    FunctionName="pension-fund-agent-handler",
    InvocationType="RequestResponse",
    Payload=json.dumps(test_event).encode("utf-8"),
)

payload = json.loads(response["Payload"].read().decode("utf-8"))
print(payload["statusCode"])
print(payload["body"])

Expected output:

200
{"member_id":"PF-TEST-001","answer":"..."}

If you want to verify the OpenAI side independently inside Lambda logs, check CloudWatch for a successful responses.create(...) call and confirm no timeout or permission errors occurred.

Real-World Use Cases

• •Member support triage:
  • •Classify incoming pension questions by urgency and route them to self-service or human advisors.
• •Document summarization:
  • •Turn long benefit statements, policy updates, or retirement packs into short agent-friendly summaries.
• •Advisor copilot:
  • •Generate draft responses for advisors after Lambda fetches member context from internal systems.

This pattern works well because Lambda keeps execution bounded and auditable, while OpenAI handles language tasks that are expensive to hard-code. For regulated environments like pension funds, that separation matters more than fancy prompt design.

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.