DEV Community: Johnathan

Code Cleanup Agents: True Multi-Agent Architecture Using Agentic Postgres

Johnathan — Mon, 10 Nov 2025 05:43:26 +0000

This is a submission for the Agentic Postgres Challenge with Tiger Data

What I Built

Code Cleanup Agents - A production-ready code analysis system that uses Tiger Data's zero-copy database forks to enable true multi-agent architecture. Four specialized AI agents work in parallel across isolated database forks, analyzing code for security vulnerabilities, quality issues, performance problems, and best practice violations.

The Problem

Modern codebases are complex, and AI-generated code is everywhere. Developers need comprehensive analysis that goes beyond simple linting - they need security scanning, performance optimization, quality checks, and best practices enforcement. Traditional tools run sequentially or require complex infrastructure to parallelize.

The Solution

By leveraging Tiger Data's fast, zero-copy database forks, I built a system where each AI agent gets its own isolated database workspace. They analyze code simultaneously without interference, then merge their findings into the main database.

Live Demo: https://code-cleanup-agents.onrender.com

Repository: https://github.com/LuminArk-AI/code-cleanup-agents.git

Key Features

✅ 4 Specialized AI Agents working in parallel

🔒 Security Agent: Detects SQL injection, hardcoded secrets, dangerous functions
✨ Quality Agent: Finds code smells, duplicates, missing documentation
⚡ Performance Agent: Identifies N+1 queries, missing indexes, inefficient patterns
📋 Best Practices Agent: Enforces language idioms, naming conventions, coding standards

✅ Real-time Analysis - Upload code, get comprehensive results in seconds

✅ Semantic Code Search - Find code patterns using natural language queries

✅ Beautiful Web Interface - Clean, intuitive UI with live feedback

✅ Production-Ready - Deployed, tested, and battle-proven on real codebases

Demo

Architecture Diagram

┌─────────────────┐
│  Code Upload    │
└────────┬────────┘
         │
    ┌────▼─────┐
    │Coordinator│
    │ (Main DB) │
    └─┬──┬──┬──┬┘
      │  │  │  │
   ┌──▼┐┌▼─┐┌▼─┐┌▼─────────────┐
   │ 🔒││✨││⚡││📋            │
   │Sec││Qua││Per││BestPractices│
   │For││For││For││   (Main)    │
   │k 1││k 2││k 3││             │
   └──┬┘└┬─┘└┬─┘└┬─────────────┘
      │  │  │  │
      └──┴──┴──┴──► Merge Results
                      │
                 ┌────▼────┐
                 │ Display │
                 └─────────┘

Screenshots

1. Tiger Dashboard - Real Database Forks
https://imgur.com/a/u3lData

Four database services: main + 3 isolated forks for agent workspaces

2. Live Analysis
https://imgur.com/a/2divPTx
*Real-time analysis finding 60+ issues across 4 specialized

3. Parallel Execution Proof
https://imgur.com/a/hXWqfDn
All agents working simultaneously in their own database forks

4. Semantic Code Search
Find code patterns using natural language with pg_trgm

5. Real-World Results
https://imgur.com/a/MA4PBol

Finding actual issues in production code - 15 improvements identified

How I Used Agentic Postgres

1. Fast, Zero-Copy Forks - The Foundation

This is the killer feature. Each agent gets its own database fork created instantly:

# Agent isolation via forks
security_engine = create_engine(SECURITY_FORK_URL)
quality_engine = create_engine(QUALITY_FORK_URL)
performance_engine = create_engine(PERFORMANCE_FORK_URL)

# Parallel execution
with ThreadPoolExecutor(max_workers=3) as executor:
    security_future = executor.submit(analyze_security, security_engine, code)
    quality_future = executor.submit(analyze_quality, quality_engine, code)
    performance_future = executor.submit(analyze_performance, performance_engine, code)

Why this matters: Traditional approaches would require complex locking, transactions, or separate database instances. With Tiger's zero-copy forks, agents can't interfere with each other's work, and we get true parallel processing for free.

Proof it works: Tiger monitoring shows simultaneous activity spikes across all three forks during analysis:

2. pg_text Search for Semantic Code Discovery

Implemented fuzzy text matching using PostgreSQL's pg_trgm extension:

CREATE EXTENSION pg_trgm;

CREATE INDEX code_content_trgm_idx 
ON code_submissions 
USING gin (code_content gin_trgm_ops);

-- Semantic search query
SELECT filename, code_content,
       similarity(code_content, 'authentication logic') as score
FROM code_submissions
WHERE similarity(code_content, 'authentication logic') > 0.2
ORDER BY score DESC;

This enables natural language queries like:

"Show me all database connection code"
"Find authentication logic"
"Where do we handle passwords?"

The similarity scores guide developers to relevant code even when exact keywords don't match.

3. Hybrid Search Combining Multiple Methods

The system combines:

Trigram similarity for fuzzy text matching
Metadata filtering for structured searches
Regex patterns for precise code pattern matching

def hybrid_search(query):
    # Semantic search via pg_trgm
    semantic_results = search_by_similarity(query)

    # Pattern matching
    pattern_results = search_by_regex(query)

    # Combine and rank results
    return merge_and_rank(semantic_results, pattern_results)

4. Intelligent Resource Allocation

I didn't just fork everything blindly. The architecture demonstrates understanding of when to use forks:

Critical analyses in isolated forks:

Security scanning (Fork 1) - Needs isolation for sensitive data
Quality analysis (Fork 2) - Heavy processing, many writes
Performance checking (Fork 3) - Complex queries on code structure

Lightweight checks on main DB:

Best Practices agent - Simple pattern matching, low overhead

This shows that forks are a tool for specific use cases, not a hammer for every nail.

5. Real-time Collaborative Analysis

Using PostgreSQL's connection pooling with asyncpg, the system supports concurrent writes from multiple agents. Each agent stores findings independently, then the coordinator merges results:

def merge_findings(submission_id):
    """Merge agent findings from forks to main database"""
    with main_db.connect() as conn:
        # Gather from all forks
        security_findings = get_from_fork(security_fork, submission_id)
        quality_findings = get_from_fork(quality_fork, submission_id)

        # Merge into main
        for finding in security_findings + quality_findings:
            conn.execute(insert_merged_finding(finding))

This demonstrates Tiger's Fluid Storage - data flows seamlessly between forks and the main database.

6. Tiger MCP Ready Architecture

While I focused on the core functionality first, the system is architected for Tiger MCP integration. Each agent is structured as an independent service that communicates through the database:

class Agent:
    def __init__(self, fork_engine, agent_type):
        self.db = fork_engine
        self.type = agent_type

    def analyze(self, code, submission_id):
        """Agent operates independently in its fork"""
        issues = self._scan(code)
        self._save_to_fork(issues, submission_id)
        return issues

This agent pattern is perfect for MCP-based orchestration in future iterations.

Overall Experience

What Worked Exceptionally Well

1. Zero-Copy Forks Are a Game Changer

Coming from traditional databases, the instant fork creation was mind-blowing. No copying data, no waiting, no complex setup. Just:

# Create fork via Tiger CLI
tiger db fork main-db --name security-agent-fork

# Boom. Ready to use.

This enabled true multi-agent architecture without the usual infrastructure headaches.

2. PostgreSQL's Rich Feature Set

Using pg_trgm for semantic search felt like discovering a superpower. No external search engine needed - just Postgres doing what it does best.

3. Developer Experience

Tiger's dashboard, monitoring, and CLI made development smooth. Seeing real-time activity graphs across forks was incredibly satisfying.

What Surprised Me

The Performance

I expected some overhead from multiple database connections, but the system analyzes a 200-line file with all 4 agents in under 2 seconds. Zero-copy forks really are zero overhead.

Finding Real Issues

When I ran my own code through it, the Best Practices agent found 10 legitimate improvements I hadn't noticed. This went from "hackathon project" to "tool I'll actually use" real quick.

How Natural It Felt

The fork-based architecture just makes sense. Each agent having its own workspace is intuitive - it mirrors how human teams work.

Challenges & Learnings

Challenge 1: Getting Fork Credentials

Initially struggled with the Tiger CLI on Windows PowerShell. Solution: Used the web dashboard to create forks and grab connection strings manually. Worked perfectly.

Learning: Have fallbacks. The coordinator gracefully handles missing fork URLs by using the main DB.

Challenge 2: Balancing Fork Usage

With Tiger's free tier (4 services total: 1 main + 3 forks), I had to think strategically about which agents needed isolation. This constraint actually led to better architecture.

Learning: Forks aren't free infrastructure - use them intentionally where they provide real value.

Challenge 3: Merge Conflicts

Initially had agents overwriting each other's results. Fixed by:

Agent-specific tables in each fork
Timestamp-based ordering
Clear merge strategy in coordinator

Learning: Even with isolated forks, you need a clean data flow design.

What I'd Do Differently

1. Earlier Integration Testing

I built each agent independently, then integrated. Should have tested the full pipeline sooner - caught some edge cases late.

2. More Language Support

Currently focused on Python. With more time, I'd add robust support for JavaScript, Java, Go, etc. The agent architecture makes this straightforward.

3. Async from the Start

The ThreadPoolExecutor works great, but full async/await would be even cleaner:

async def analyze_code():
    results = await asyncio.gather(
        security_agent.analyze(code),
        quality_agent.analyze(code),
        performance_agent.analyze(code)
    )

Key Takeaways

1. Database Forks Enable New Architectures

Before Tiger, true multi-agent systems required microservices, message queues, or complex coordination. Forks make it trivial.

2. PostgreSQL is Underrated for AI Systems

We reach for vector databases and specialized tools, but Postgres + extensions handles 90% of use cases beautifully.

3. Start Simple, Scale Smart

My initial plan had 6 agents and complex orchestration. Focusing on 4 well-implemented agents was the right call.

Future Roadmap

With the foundation solid, here's what's next:

AI-Powered Fix Generation: Use Claude API to automatically generate code fixes
GitHub Integration: Analyze entire repositories, generate PR comments
Historical Tracking: Use TimescaleDB features to track code quality over time
Team Features: Multi-user support, project management, quality dashboards
CI/CD Integration: Run as part of automated pipelines
More Languages: JavaScript, TypeScript, Java, Go, Rust support

Try It Yourself

Code Cleanup Agents

Live Demo: https://code-cleanup-agents.onrender.com

GitHub: https://github.com/LuminArk-AI/code-cleanup-agents.git

Setup Instructions:

Running locally

Get Tiger Data account
Create databases
Clone this repo
Add your database URLs to .env
Run python app.py

Conclusion

Building Code Cleanup Agents taught me that the right infrastructure unlocks new possibilities. Tiger Data's Agentic Postgres features - especially zero-copy forks - enabled an architecture that would have been impractical with traditional databases.

This isn't just a hackathon project. I'm using it on my own code, it's finding real issues, and the agent-based architecture is extensible for countless improvements.

The future of development tooling is multi-agent systems. Agentic Postgres makes that future practical today.

Built with: Python, Flask, PostgreSQL, Tiger Data, SQLAlchemy, and lots of coffee ☕

GitHub: https://github.com/LuminArk-AI

Thanks to Tiger Data and the DEV community for an amazing challenge!

🧃 Juice Oracle: The AI That Judges Your Soul Through Your Beverages

Johnathan — Thu, 11 Sep 2025 18:06:28 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

Meet the Juice Oracle - a mystical AI that delivers brutally honest personality roasts based on your beverage choices. This isn't your typical drink analyzer - it's a savage personality assessment tool that combines advanced image recognition with creative AI roasting to judge your deepest character flaws through your drink preferences.

Simply upload a photo of any beverage and watch the Oracle deliver devastating (but hilarious) insights about your personality, life choices, and what your drink says about you. From budget root beer to artisanal kombucha, no beverage escapes the Oracle's merciless judgment.

Problem it solves: Turns mundane beverage consumption into shareable entertainment while showcasing the creative potential of multimodal AI.

Demo

🔮 Live Demo: https://juiceoracle.netlify.app/

Example Oracle Roast

🧃 Great Value Root Beer

"You're the human equivalent of a participation trophy - technically a winner, but everyone knows it's just cheap. Your idea of sophistication is adding a straw."

Personality Type: The Economical Nostalgist
Oracle Rating: 3/10 - at least you're saving money...
eventually
Demo mode: available for testing without API key setup, if you don't have one.
Images: https://imgur.com/a/Ji9wwiD

How I Used Google AI Studio

The Juice Oracle is powered by Google AI Studio's Gemini 2.0 Flash model, leveraging its multimodal capabilities through the Generative Language API. The implementation uses:

Image analysis for precise beverage identification
Creative text generation with custom prompting for consistent Oracle personality

JSON-structured responses for clean UI integration
Real-time processing with optimized prompts for fast, entertaining results

The Oracle's "personality" is achieved through carefully crafted system prompts that instruct Gemini to analyze beverages and respond as a "mystical, slightly savage AI entity" - creating memorable, shareable content.

Multimodal Features

🖼️ Advanced Image Recognition: Identifies specific beverages, brands, and even drink conditions (cheap vs premium, homemade vs store-bought) with remarkable accuracy.

📱 Seamless Camera Integration: Mobile-optimized camera capture with live preview, allowing instant beverage photography and analysis from any device.

🎭 Contextual Personality Analysis: Combines visual recognition with creative AI to generate roasts that are specifically tailored to the identified beverage - not generic responses.

💬 Social-Ready Content: Results formatted as shareable "roast cards" with personality types, compatibility ratings, and memorable one-liners.

Why This Enhances UX

Instant Gratification: Point camera → capture → get roasted in seconds
Personalized Entertainment: Every beverage receives a unique, targeted analysis
Viral Potential: Creates memorable, screenshot-worthy moments
Accessibility: Works across all devices with camera or file upload options

The Oracle proves that sophisticated AI doesn't have to be serious - sometimes the best way to showcase multimodal capabilities is through pure, engaging entertainment that people actually want to use and share.

Ready to face the Oracle's judgment? 🧃🔥

I Built a 6-Headed AI Intelligence System (No Subscriptions Required!)

Johnathan — Fri, 29 Aug 2025 19:00:12 +0000

🐉 HYDRA: How I Turned a $1000 prize Competition Entry into a FREE Open-Source Tool

TL;DR: Started building for a competition that required expensive tools (n8n + Bright Data), said "screw that," and rebuilt everything to be 100% FREE. Now it's a 6-headed AI beast that monitors competitors 24/7 without any subscriptions.

Try the live demo - no signup, no BS, just click and see it work

[🔥Live Demo] https://hydra-intelligence-system.onrender.com [📝 GitHub Repo] https://github.com/CryptoBitwise/Hydra-Intelligence-System.git

🤔 The Problem That Started Everything

Last month, I entered a "Real-Time AI Agents Challenge" that required using:

n8n (workflow automation) → $20-98/month after trial
Bright Data (web scraping) → $100-300/month for real use

Total cost was a lot: $200-500/month 🤯

That's when I thought: "What if I built something actually FREE?"

🐉 Enter HYDRA: 6 Heads, 0 Subscriptions

HYDRA is a competitive intelligence system with 6 specialized "heads" that monitor different aspects of your competitors:


python
HYDRA_HEADS = {
    "👁️ PriceWatch": "Catches pricing changes in real-time",
    "🎯 JobSpy": "Tracks hiring to reveal strategic moves", 
    "📡 TechRadar": "Detects tech stack changes",
    "💭 SocialPulse": "Monitors brand sentiment",
    "📋 PatentHawk": "Watches innovation filings",
    "📊 AdTracker": "Analyzes marketing campaigns"
}

🚀 Building Viral Hunts: AI Scavenger App with Expo & NFTs – Dev Feedback Needed! 💻🎮

Johnathan — Wed, 27 Aug 2025 16:30:34 +0000

Hey r/dev! I’m a student dev (part of program across 6 schools) working on Viral Hunts, a mobile scavenger hunt app. It uses AI to generate clues from TikTok/X trends (e.g., “Visit the viral pizza spot”), rewards players with NFTs (via OpenSea), and adds lightweight 2D AR badges (8th Wall). We’re aiming for a demo by December 2025, and it’s built to go viral with Gen Z!
Check our mockup:
https://imgur.com/a/B0tEeE2

(Neon UI, “Trending Now” AI refresh, TikTok Famous Pizza Spot hunt—thoughts on the design?)
Tech Stack:
Frontend: Expo React Native (cross-platform iOS/Android). Using Cursor to generate lean components (e.g., clue screens, leaderboard).
AI: Grok API (x.ai/api) for text-based clue generation from social media—CPU-only, no GPU training.
AR: 8th Wall for lightweight 2D overlays, triggered by GPS (Expo Location).
NFTs: OpenSea API for minting/displaying badges.
Backend: Firebase for user scores and hunt progress.
Challenges & Questions:
How can I optimize Expo React Native performance for 100+ concurrent users (e.g., leaderboard updates)?
Any tips for integrating 8th Wall AR smoothly with React Native? (Current setup uses JS triggers.)
Best practices for scaling Firebase with NFT trade tracking?
Suggestions for Cursor prompts to streamline coding (e.g., “Generate a clue card component”)?
We’re keeping it GPU-light to focus on startup growth (no heavy AI training or 3D graphics). Monetization’s via premium hunts ($1-5), NFT fees, and biz sponsors. No sales pitch—just want dev insights to level up! What do you think of the concept or tech? Any gotchas to avoid? Thanks! 😄

Knowledge OS — Turning Any File into Instant, Cited Answers with Redis 8

Johnathan — Mon, 11 Aug 2025 00:25:44 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

Knowledge OS — From Data to Decisions in Seconds
Submission for the Redis AI Challenge

🚀 Turn messy PDFs, Word files, spreadsheets, and URLs into instant, cited answers — powered by Redis 8 + AI agents.
No endless searching. No manual note-taking. Just drop, ask, and decide.

What I Built:
Knowledge OS is an AI-powered command center for documents.
Drop in PDFs, DOCX, XLSX, images, or even URLs—our AI agent swarm ingests, cleans, summarizes, and indexes everything so you can ask natural questions and get cited answers in seconds.

Typical asks

“Summarize all invoices over $5,000.”

“What’s the refund policy in this contract?”

“Key points and conclusion from this article URL.”

Every answer links back to the exact source passage. ⚡️

Demo
🔴 Live: (Netlify): https://knowledgeosdemo.netlify.app/

🎥 Video: https://youtu.be/Lys6WacZxTc

📷 Screenshots: N/A

Dashboard & file drop

Agents in action (Ingest → OCR → Summarize → Index)

Redis Cloud: Streams + Vector Search

Smart chat with citations

Why This Matters
Teams waste hours hunting through PDFs and tabs. Knowledge OS turns that into seconds with reliable, cited answers—great for audits, ops, research, and finance workflows.

How I Used Redis 8
Redis Cloud v8 is the real-time backbone:

Streams – Orchestrates AI agents
ingest → ocr → embed → index → answer

Vector Search – Embedding-based retrieval across all pages and URLs

RedisJSON – Rich metadata (title, dates, vendor, totals, tags)

Semantic/summary caching – Sub-10ms repeat answers and table rollups

This combo gives me low-latency answers with source citations at interactive speeds.

Architecture (High-Level)
pgsql
Copy
Edit
Upload/URL
│
▼
Ingest Agent ──► OCR/Parser ──► Chunk & Embed ──► Indexer
│ │ │ │
└──► Redis Streams (task handoffs) │ │
▼ ▼
Redis Vector RedisJSON (metadata)
Index
│
User Chat ──► Retriever ──► LLM (with citations) ──► Answer + Source links
▲ └─► Cache (Redis) for repeats
└─────────────► Metrics / Logs
Tech Stack
Frontend: React / Next.js (demo UI), CapCut for demo video

Agents/Backend: Node/Python, queues via Redis Streams

Search: Redis Vector Search (OpenAI/all-MiniLM embeddings)

Storage/Metadata: RedisJSON

Hosting: Netlify (demo), Redis Cloud (data layer)

How to Try It (Local)
1) Environment
bash
Copy
Edit
export REDIS_URL="rediss://:@:"
export OPENAI_API_KEY= # or your LLM provider
2) Install + run
bash
Copy
Edit
npm install
npm run dev
3) In the app
Drop a PDF/Doc/URL

Ask a question

Click citations to jump to source
What’s Next
Role-based redaction (PII hiding) before indexing

Multi-doc table extraction → CSV export

Org spaces & SSO

Fine-tuned domain prompts

Q&A are most welcomed! Ask away!!

Team / Credits
Solo build by: Johnathan Jake @jjake486@gmail.com
Thanks, Redis team & judges!