What I Built
AgenticForkSquad (AFS) is an AI-powered database query optimizer that uses multi-agent collaboration to automatically improve slow SQL queries.
The system leverages Tiger Cloud's zero-copy forks to create isolated testing environments for three specialized AI agents (powered by Google Vertex AI):
🧠 Cerebro Agent (gemini-2.5-pro): Strategic planner & quality assurance
⚡ Operativo Agent (gemini-2.5-flash): Code generator & execution specialist
🔧 Bulk Agent (gemini-2.0-flash): High-volume operations optimizer
Each agent analyzes the query in its own Tiger Cloud fork, proposes optimizations, runs benchmarks, and competes in a consensus engine that evaluates:
Performance improvement (50%)
Storage efficiency (20%)
Code complexity (20%)
Implementation risk (10%)
The winning optimization is automatically applied to the main database, and all forks are cleaned up.
Demo
🌐 Live Application: https://agentic-fork-squad.vercel.app
🐙 GitHub Repository: https://github.com/HCo-Innova/AgenticForkSquad
📚 Documentation: See docs folder for complete architecture
Quick Start
Login with test credentials
Submit a query: SELECT * FROM tasks WHERE status = 'pending' ORDER BY created_at DESC
Watch real-time WebSocket updates as 3 agents process in parallel
Review consensus decision with benchmarks
See optimized query applied
Tiger Cloud Features Showcase
✅ Zero-Copy Forks (Core Feature)
Every task creates 3 isolated database forks instantly:
// Real fork creation via Tiger MCP
forkID, err := mcpClient.CreateFork(ctx, mainService, "fork-cerebro-task1")
// Returns pre-created fork: gwb579t287 (Agent 1) or mn4o89xewb (Agent 2)
MCP enables programmatic fork management, making multi-agent workflows possible.
✅ Multi-Agent Collaboration
Three agents work in parallel forks:
Cerebro analyzes query patterns in fork-cerebro
Operativo generates optimizations in fork-operativo
Bulk tests scalability in fork-bulk
All running simultaneously on Tiger Cloud without blocking each other.
✅ Real PostgreSQL Features
Full access to Tiger Cloud's PostgreSQL 16:
Information schema introspection
EXPLAIN ANALYZE for benchmarks
Index creation/deletion in forks
Transaction isolation testing
Journey & Tech Stack
Architecture
Backend: Go 1.21 with Fiber v2 (Clean Architecture pattern)
Frontend: React 18 + TypeScript + Vite + Tailwind CSS
Database: Tiger Cloud PostgreSQL 16
AI: Google Vertex AI (3 Gemini models)
MCP: Tiger Cloud MCP Server
Real-time: WebSocket Hub for live updates
Workflow
User submits slow query
↓
Router assigns 3 agents based on query complexity
↓
TaskProcessor creates 3 Tiger Cloud forks via MCP
↓
Orchestrator executes agents in parallel (10min timeout each)
↓
Each agent: Analyze → Propose → Benchmark in its fork
↓
ConsensusEngine scores proposals (multi-criteria)
↓
Winner applied to main DB
↓
Forks deleted (cleanup)
↓
WebSocket broadcasts completion to UI
Key Implementation Details
Fork Management:
type MCPClient struct {
fork1URL string // gwb579t287 (pre-created)
fork2URL string // mn4o89xewb (pre-created)
mainURL string // wuj5xa6zpz
}
We use persistent pre-created forks to ensure reliability. Each agent gets assigned a dedicated fork ID.
Consensus Scoring:
func (ce *ConsensusEngine) Decide(
proposals []*OptimizationProposal,
benchmarks []*BenchmarkResult,
criteria ScoringCriteria,
) (*ConsensusDecision, error)
Weighted scoring prevents agents from over-optimizing single metrics.
Real-time Updates:
// 11 WebSocket event types
EventTaskCreated
EventAgentsAssigned
EventForkCreated
EventAnalysisCompleted
EventProposalSubmitted
EventBenchmarkCompleted
EventConsensusReached
EventOptimizationApplied
EventTaskCompleted
EventTaskFailed
EventConnectionEstablished
Users see every step of the multi-agent workflow live.
Why Tiger Cloud Made This Possible
Before Tiger Cloud: Multi-agent database testing required:
Complex database replication setup
Manual fork management
Storage costs for duplicated data
Synchronization headaches
With Tiger Cloud:
One line of code creates a fork: CreateFork(ctx, parent, name)
Zero storage overhead (copy-on-write)
Instant creation (no wait time)
Perfect isolation (agents can't interfere)
MCP standard (works with any MCP client)
This project would be impractical without Tiger Cloud's zero-copy forks. Traditional database cloning would make parallel agent execution too slow and expensive.
What's Next
Hybrid search integration (pg_text) for query pattern matching
PITR (Point-in-Time Recovery) for rollback testing
Agent learning from previous optimizations
Fluid Storage for dynamic fork lifecycle
Production deployment (Vercel + Railway)
Technical Highlights
Clean Architecture Layers:
Domain (entities, interfaces, values)
↓
UseCases (orchestrator, consensus, agents)
↓
Infrastructure (MCP, Vertex AI, PostgreSQL)
↓
Presentation (HTTP handlers, WebSocket)
Database Schema:
tasks - User-submitted queries
agent_executions - Agent activity logs
optimization_proposals - AI-generated solutions
benchmark_results - Performance metrics
consensus_decisions - Winning selections
Testing:
All Tiger Cloud interactions are production-ready:
Direct PostgreSQL connections to forks
Error handling for fork unavailability
Graceful degradation if MCP unreachable
Transaction safety in main DB
Conclusion
AgenticForkSquad demonstrates how Tiger Cloud's Agentic Postgres enables a new class of AI applications:
✅ Multi-agent systems that need isolated testing environments
✅ Parallel experimentation without storage penalties
✅ Safe production updates via fork-test-apply workflow
✅ MCP integration for programmatic database management
Tiger Cloud's zero-copy forks transformed database testing from a bottleneck into an enabler for AI collaboration.
Top comments (0)