⭐ AI Agent Platform — Project Case Study

URL: AIAgent.LinhTruong.com

🚀 Overview

AIMnow.AI is a multi‑agent automation platform designed to execute complex business workflows such as SDR outreach, customer support triage, claims intake, and marketing operations. The system uses specialized AI agents with role‑based behaviors, shared memory, and deterministic workflow execution to deliver enterprise‑grade reliability.

The platform is built for organizations that need automation with transparency, auditability, and human‑override capability — not just “chatbots.”

👨‍💻 My Role

I led the full engineering lifecycle:

Architecture:
Multi‑agent orchestration, workflow engine, memory systems
Backend:
Node.js, Python, FastAPI microservices
AI/ML:
Prompt engineering, RAG pipelines, agent coordination logic
Frontend:
React/Angular dashboards for monitoring and configuration
DevOps:
Docker, Kubernetes, CI/CD, observability
Integrations:
Email, SMS, CRM, vector DB, authentication

🧩 Problem & Constraints

The platform needed to automate multi‑step communication workflows across multiple departments. Key constraints:

Agents must maintain consistent persona and tone
Workflows require state persistence and branching logic
Operators need real‑time visibility and override controls
Integrations with CRM, email, SMS, and internal APIs
Must minimize token usage while maintaining accuracy
Must scale to multiple agents running concurrently

These constraints shaped the architecture and engineering decisions.

🏗️ 1. System Architecture Diagram (Hybrid Grid Layout)

┌───────────────────────────────┬───────────────────────────────┬───────────────────────────────┐
│           Frontend            │        API Gateway Layer       │       Event Bus / Logging      │
│ (React/Angular Dashboards)    │ (Auth, Routing, Throttles)     │ (Real-Time Streams + Audit)    │
└───────────────┬───────────────┴───────────────┬───────────────┴───────────────┬───────────────┘
                │                               │                               │
                ▼                               ▼                               ▼
        ┌──────────────────────────┐     ┌──────────────────────────┐     ┌──────────────────────────┐
        │     Agent Orchestrator   │     │     Workflow Engine      │     │     Shared Memory (DB)    │
        │ (Routing + Coordination) │     │  (State Machine Logic)   │     │  (Vector DB + Metadata)   │
        └───────────────┬──────────┘     └───────────────┬──────────┘     └───────────────┬──────────┘
                        │                               │                               │
                        ▼                               ▼                               ▼
        ┌──────────────────────────┐     ┌──────────────────────────┐     ┌──────────────────────────┐
        │        SDR Agent         │     │      Support Agent       │     │       Claims Agent        │
        │   (Outbound Sequences)   │     │     (Triage Logic)       │     │      (Intake Forms)       │
        └───────────────┬──────────┘     └───────────────┬──────────┘     └───────────────┬──────────┘
                        │                               │                               │
                        └───────────────┬───────────────┴───────────────┬───────────────┘
                                        ▼                               ▼
                              ┌──────────────────────────┐     ┌──────────────────────────┐
                              │        RAG Pipeline       │     │        LLM Layer          │
                              │ (Embeddings + Retrieval)  │     │   (GPT / Claude Models)   │
                              └──────────────────────────┘     └──────────────────────────┘

🔄 2. Data Flow Diagram (Hybrid Grid Layout)

┌──────────────────────────┐
│ 1. User Input / Trigger  │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 2. API Gateway           │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 3. Agent Orchestrator    │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 4. Select Agent          │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 5. Retrieve Memory (RAG) │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 6. Construct Context     │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 7. LLM Generation        │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 8. Validate Output       │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 9. Workflow Engine       │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 10. Emit Events to UI    │
└──────────────────────────┘

🔁 3. Workflow Diagram (Hybrid Grid Layout)

┌──────────────────────────┐
│ 1. Workflow Triggered    │
│ (Email, API, Timer, UI)  │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 2. Orchestrator Routes   │
│    to Correct Agent      │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 3. Agent Loads Context   │
│    + Memory              │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 4. Agent Generates       │
│    Structured Output     │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 5. Workflow Engine       │
│    Updates State         │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 6. Branch Logic          │
│ (Next Step / Complete)   │
└───────────────┬──────────┘
                ▼
┌──────────────────────────┐
│ 7. UI + Logs Updated     │
└──────────────────────────┘

🤖 4. Multi‑Agent Coordination Diagram (Hybrid Grid Layout)

┌──────────────────────────┐
│      Agent Orchestrator  │
│ (Routing + Coordination) │
└───────────────┬──────────┘
                │
 ┌──────────────┼───────────────────────────────┐
 │              │                               │
 ▼              ▼                               ▼
┌──────────┐  ┌──────────┐                 ┌──────────┐
│ SDR Agent│  │Support Ag│                 │Claims Ag │
│ (Sales)  │  │ (Support)│                 │ (Intake) │
└─────┬────┘  └─────┬────┘                 └─────┬────┘
      │             │                          │
      └─────────────┼───────────────┬──────────┘
                    ▼               ▼
          ┌──────────────────┐   ┌──────────────────┐
          │ Shared Memory    │   │ RAG Pipeline     │
          │ (Vector DB)      │   │ (Docs + Embeds)  │
          └─────────┬────────┘   └─────────┬────────┘
                    │                      │
                    ▼                      ▼
          ┌──────────────────┐   ┌──────────────────┐
          │   LLM Layer      │   │ Workflow Engine   │
          │ (GPT / Claude)   │   │ (State Machine)   │
          └──────────────────┘   └──────────────────┘

🎨 UX & Design Rationale

The platform’s UI was intentionally designed to support enterprise operators:

Real‑time logs reveal agent reasoning
Clear separation between configuration and execution
Minimalist layout reduces cognitive load
Color‑coded states highlight workflow progress
Human override controls ensure safety and compliance

🔬 Technical Deep Dive

Multi‑Agent Coordination

Role‑based prompts
Shared memory with vector search
Context injection
Guardrails to prevent hallucinations

RAG Pipeline

Chunking + embeddings
Context scoring
Relevance filtering
Dynamic context window construction

Workflow Engine

Deterministic state machine
Retry logic
Structured output validation
Error recovery

Performance Optimizations

~40% token reduction
Caching of embeddings
Parallel execution

Observability

Latency tracking
Token cost monitoring
Agent accuracy metrics
Event logs

📈 Results & Impact

70% reduction
in manual SDR workload
Faster support triage
Automated claims intake
Enterprise‑ready dashboards
Scalable multi‑agent foundation

🔗 Live Demo

AIAgent.LinhTruong.com

Linh Truong

Case Study – AIAgent