REMEDI:Agentic AWS Security & Remediation Platform
A full-stack agentic security platform that scans an AWS account across 8 services, generates a findings report, waits for human approval, auto-remediates every vulnerability, then runs a verification pass, all orchestrated by a 5-stage LangGraph pipeline with 8 parallel specialist sub-agents.
Core Impact
“Audits 8 AWS services in parallel in under 5 minutes with zero unauthorized changes via a LangGraph human-in-the-loop safety gate and deterministic MCP tool dispatch.”
8
AWS services audited in parallel
$0.02
Cost per full account scan
100%
Findings auto-fixed after one approval
The Problem
Checking an AWS account for security holes used to mean opening eight different service consoles by hand: IAM, S3, EC2, VPC, RDS, Lambda, CloudTrail, Security Groups. You need to know what to look for in each one, then fix every problem yourself. It's slow, you miss things, and the audit goes stale the moment you finish. I wanted something that scans all eight at once, shows me every fix before it touches anything, and does the work itself once I approve.
The Approach
Why eight parallel agents
Each AWS service gets its own agent with its own tools and its own LLM loop, and they all run at the same time through a ThreadPoolExecutor. Running eight services one after another is slow. Running them together drops the whole scan to about the time one service takes, so a full audit feels instant instead of a coffee break.
Why a human-in-the-loop gate
Nothing touches your account without you saying yes. The pipeline is a LangGraph state machine with an interrupt_before checkpoint that stops right after it builds the report. Every change it wants to make shows up in the dashboard first, and it only starts fixing things once you approve.
Why isolate boto3 behind MCP
All the AWS calls live in a separate process that talks over stdio, so your credentials never even enter the agent. A background asyncio loop connects that process to LangGraph's synchronous ToolNode. That bridge is the reason eight agents can share one pipe at the same time without their event loops colliding.
Why no LLM in the remediation step
The remediator reads the report with plain regex instead of asking the model what to fix. No extra wait, no malformed JSON, no chance of the model inventing a fix that doesn't exist. Each finding maps straight to the one tool that resolves it.
Why Celery + Redis for scan dispatch
A scan runs for minutes, so the API can't just wait on it. A Celery worker owns the scan, streams progress into a Redis stream that the frontend reads over SSE, and blocks on a Redis list until the human approval decision lands. FastAPI stays free to answer other requests the whole time.
Technical Deep Dive
Architected 8-parallel-agent orchestration layer using LangGraph and ThreadPoolExecutor, spawning one specialist sub-agent per AWS service (IAM, S3, EC2, VPC, RDS, Lambda, CloudTrail, Security Groups) with isolated tool sets and LLM loops; parallel execution cuts scan time ~8x vs. sequential.
Implemented 5-stage interrupt-based state machine (Orchestrator → Report Generator → Safety Gate → Remediator → Verifier) with LangGraph's `interrupt_before` checkpoint. Zero AWS changes execute without explicit operator approval; agent auto-remediates 100% of detected vulnerabilities after single sign-off.
Engineered custom MCP server subprocess (JSON-RPC over stdio) isolating all boto3 calls from LangGraph; background asyncio event loop bridges async MCP protocol to synchronous LangGraph ToolNode, preventing event-loop conflicts across 8 concurrent agent threads.
Implemented 3-layer credential security: Fernet encryption at rest, 30-min inactivity purge (background thread, 5-min sweep interval), explicit wipe on sign-out. Zero plaintext credentials touch disk.
Mapped 8 CIS AWS Foundations Benchmark controls to automated scan checks with per-control pass/fail and aggregate compliance scoring stored in PostgreSQL; reduced per-scan LLM cost to ~$0.02 using Gemini 2.0 Flash.
Instrumented end-to-end observability via LangSmith. Every LLM call, tool invocation, and latency across all 5 pipeline phases captured as structured traces; 25-test suite (24 passed, 1 xfailed/moto limitation) covers credential encryption, remediation tools, and report parser.
Decoupled scan execution from the API with a Celery + Redis task queue: `/api/run-agent` hands each scan to a worker and returns immediately, the worker streams `main.py`'s stdout into a Redis stream for SSE, and blocks on a Redis list while awaiting the human approval decision.
Systems Analysis Concluded