How We Turned CAMEL-AI Agents into Real Systems Using AWS RDS

In our recent work at Optimum Partners, we pushed beyond the typical AI chatbot experiment. We connected CAMEL-AI—an open multi-agent framework—to Amazon RDS for PostgreSQL. This wasn’t a demo. It was a working use case: agents thinking, remembering, and acting across a live data stack.

Here’s what we did, why we did it, and what it unlocked.

The Problem We Wanted to Solve

We needed more than a clever LLM wrapper. Our project required agents that could:

• Share memory across time and across roles
• Act on fresh data from a real database
• Simulate complex workflows with minimal hardcoding

Existing solutions were either too shallow (single-agent prompts with no memory) or too brittle (hardwired logic that didn’t scale).

So we built something different.

What We Built: CAMEL-AI Agents + PostgreSQL on RDS

We used CAMEL-AI to define multiple agents, each with a unique role—planner, executor, monitor, analyst. Each agent operated independently but followed a shared mission.

To turn this from a toy into a system, we connected them to Amazon RDS (PostgreSQL). Now the agents could persist memory, share context, and make decisions based on actual data—not static prompts.

Why the Database Layer Changed Everything

Long-Term, Shared Memory
Each agent could write to and query the same structured memory. We didn’t need to stuff everything into a single prompt window. Context persisted across runs.

Data-Based Decisions
Instead of hallucinating, agents ran SQL queries: pulling history, validating status, comparing metrics, updating records. Real data, real logic.

Simulations That Felt Real
We tested coordination workflows: one agent assigns, another executes, another escalates. With RDS as the shared backend, simulations behaved like real systems—because they were.

Stable Infra, Zero Headaches
With AWS RDS, we didn’t need to worry about scaling, patching, or backups. The agents just ran. We focused on design, not plumbing.

Agentic Architecture, Not a Demo
Each agent was a first-class system actor. No one-off prompt hacks. No fragile chains. Just clear roles, clear memory, and clean logic.

Our Learnings

• Schema matters: a clean, well-structured PostgreSQL schema made agent reasoning more accurate and reliable.
• Logs saved us: logging agent inputs, outputs, and SQL queries was crucial for debugging and iteration.
• Keep it simple: we got more mileage from fewer agents with clear separation of responsibilities.

Why We’re Sharing This

This wasn’t about experimenting with AI. It was about extending our engineering stack with something real.

CAMEL-AI gave us structure. RDS gave us memory. The result: agents that don’t just respond—they operate.

We’re already using this pattern to prototype internal tools, automate workflows, and simulate decision trees.

It’s early. But it’s working.