backend-factory

Discovers all external API calls, third-party SDK usage, webhook subscriptions, and API contracts in the codebase. Visualizes external services as trading post portals on the factory perimeter. Use this agent to understand and visualize third-party dependencies. <example> Context: User wants to see what external services the backend depends on user: "What external APIs does this project talk to?" assistant: "I'll launch the **api-integrator** agent to discover all external API calls, SDK usage, and webhook subscriptions." <commentary>The api-integrator scans for outbound HTTP calls (fetch, axios, http.request), known SDK imports (Stripe, AWS, Twilio), API spec files (OpenAPI, protobuf), and webhook registrations to build a complete map of external dependencies. Each discovered service becomes a trading post portal on the factory perimeter.</commentary> </example> <example> Context: User is concerned about reliability of external integrations user: "Are there any external calls without retry logic?" assistant: "I'll launch the **api-integrator** agent with risk assessment to check for missing timeouts, retries, and circuit breakers on all external calls." <commentary>The api-integrator performs integration risk assessment by analyzing error handling patterns around each external call site, flagging single points of failure, missing timeout configurations, and absent retry logic.</commentary> </example>

This document defines how Backend Factory agents share data to produce richer, emergent output.

Maps file-to-file dependencies by parsing import/require statements across the codebase. Builds an actual dependency graph showing which files depend on which. Use this agent to create accurate edges between nodes in the factory visualization. <example> Context: The factory visualization needs accurate connections between components user: "/factory-analyze" assistant: "I'll launch the **dependency-mapper** agent to trace actual imports between your route, service, and model files." <commentary>Rather than guessing connections, the dependency-mapper reads every relevant file's imports and builds a real dependency graph.</commentary> </example>

Traces the complete request flow for a specific route by following imports, function calls, and middleware chains through the source code. Use this agent when you need to build an accurate, file-by-file flow path for a single API endpoint. <example> Context: User wants to see how POST /api/messages flows through their backend user: "trace POST /api/messages" assistant: "I'll launch the **flow-tracer** agent to follow the complete request path for POST /api/messages through your codebase." <commentary>The flow-tracer starts at the route definition, follows the handler function, traces imports to service files, then to database/cache/queue calls, building a complete ordered flow.</commentary> </example> <example> Context: Factory visualization shows a route but the flow seems incomplete user: "The flow for GET /users doesn't show the cache check" assistant: "Let me launch the **flow-tracer** agent to do a deeper trace of GET /users and find the cache interaction." <commentary>Flow-tracer reads the actual handler code, follows function calls across files, and identifies cache/DB/queue interactions that grep-based detection might miss.</commentary> </example>

Deep analysis agent that identifies the backend framework, language, and project structure. Use this agent when you need to determine what framework a project uses, find its entry points, and understand its directory conventions before running component detection. <example> Context: User runs /factory-start on a new project user: "/factory-start" assistant: "I'll launch the **framework-detective** agent to identify your backend framework and entry points." <commentary>The framework-detective scans package.json, requirements.txt, go.mod, directory structure, and import patterns to identify the exact framework, version, entry point files, and project layout conventions.</commentary> </example> <example> Context: Analysis returned "unknown" framework user: "It didn't detect my framework" assistant: "Let me launch the **framework-detective** agent with deeper analysis to look at import patterns and file structure." <commentary>When basic detection fails, the framework-detective does deeper heuristic analysis including reading actual source files for framework-specific patterns.</commentary> </example>

Maps deployment infrastructure by parsing Dockerfiles, docker-compose.yml, Kubernetes YAMLs, Terraform configs, CI/CD pipelines, and environment files. Extends the factory beyond code into its deployment landscape, showing satellite factories and resource depots. <example> Context: User wants to see how their backend is deployed user: "/factory-analyze infrastructure" assistant: "I'll launch the **infrastructure-cartographer** agent to map your deployment landscape — containers, pipelines, and cloud resources." <commentary>The infrastructure-cartographer scans Dockerfiles, docker-compose.yml, Kubernetes manifests, Terraform configs, CI/CD workflows, and environment files to build a complete deployment topology that extends the factory visualization with satellite work pods and supply chains.</commentary> </example> <example> Context: Project has complex multi-service Docker Compose with Kubernetes deployment user: "How do my services connect in production?" assistant: "Let me launch the **infrastructure-cartographer** agent to trace your container definitions and Kubernetes manifests — I'll map every service, port, and dependency." <commentary>When a project has layered infrastructure (Docker for local dev, Kubernetes for production), the infrastructure-cartographer correlates container definitions with K8s deployments to show the full deployment picture — which container runs which code, how they scale, and how traffic flows between them.</commentary> </example>

Determines the exact execution order of middleware in the backend by reading the app initialization file. Use this agent to build an accurate middleware pipeline for the factory visualization. <example> Context: Factory needs to show middleware in the correct order user: "/factory-analyze" assistant: "I'll launch the **middleware-orderer** agent to determine the exact middleware execution order." <commentary>Middleware order matters — auth before route handlers, CORS before everything, error handlers last. This agent reads the app setup to get the real order.</commentary> </example>

Analyzes backend code for performance bottlenecks, N+1 queries, missing caching, blocking operations, and inefficient patterns. Outputs latency estimates that drive character animation speed in the factory. Use this agent to identify slow stations and optimize the factory's throughput. <example> Context: User wants to find why their factory visualization shows slow stations user: "Why are some of my factory stations so slow?" assistant: "I'll launch the **performance-pundit** agent to analyze your backend for bottlenecks and latency hotspots." <commentary>The performance-pundit scans all data access patterns, middleware chains, async code, and query patterns to produce per-node latency estimates and an overall efficiency score. Bottlenecks are surfaced with factory-themed narration.</commentary> </example> <example> Context: User wants to optimize a specific route that appears as a bottleneck user: "The /reports endpoint is showing as a bottleneck in my factory" assistant: "Let me launch the **performance-pundit** agent focused on that route to diagnose the exact cause and suggest fixes." <commentary>When targeting a specific route, the performance-pundit traces the full request path — middleware, handler, DB queries, serialization — to pinpoint where time is lost and recommend concrete optimizations.</commentary> </example>

Finds and analyzes database models, schemas, and data definitions in the codebase. Detects Prisma schemas, Sequelize models, Mongoose schemas, SQLAlchemy models, TypeORM entities, and raw SQL migrations. Use this agent to enrich database stations in the factory visualization. <example> Context: Factory shows a generic "Database" station but user wants more detail user: "Can you show what tables the database has?" assistant: "I'll launch the **schema-explorer** agent to find all your database models and their relationships." <commentary>The schema-explorer reads ORM model files, Prisma schemas, and migration files to extract table names, columns, and relationships.</commentary> </example>

Scans backend codebases for security vulnerabilities, insecure patterns, exposed secrets, and weak configurations. Visualizes weak points as factory hazards with alarming narration. Use this agent to identify security risks and enrich the factory with security posture data. <example> Context: User wants a security audit of their backend before deployment user: "/factory-security-scan" assistant: "I'll deploy the **security-sentinel** agent to sweep every floor of your factory for unlocked doors, exposed wiring, and missing guardrails." <commentary>The security-sentinel scans for hardcoded secrets, injection risks, insecure auth patterns, missing security headers, and dependency vulnerabilities — then maps each finding onto the factory as a visual hazard.</commentary> </example> <example> Context: User notices the factory visualization shows a route handler with no auth middleware user: "That /admin route has no security — is that a real problem?" assistant: "Let me send the **security-sentinel** agent to inspect that section of the factory and report on every vulnerability it finds." <commentary>When targeted at specific routes or components, the security-sentinel performs deep analysis of that code path — checking for auth gaps, input validation, injection risks, and privilege escalation vectors.</commentary> </example>

Takes architecture analysis data and generates/updates the factory visualization. Handles starting the server, sending data, and verifying the visualization is working. Use this agent for the final step of any factory workflow. <example> Context: Analysis is complete and needs to be rendered user: "/factory-start" assistant: "Analysis complete. Launching the **visualization-builder** agent to start the factory server and render your architecture." <commentary>The visualization-builder takes the aggregated architecture JSON, starts the server, POSTs the data, and confirms the factory is rendering.</commentary> </example>

Re-scan the current project's backend architecture and update the running factory visualization

Trace a data entity's complete lifecycle across the entire backend

Compare architecture between two git commits or branches and visualize the differences

Export the current factory architecture as JSON, HTML snapshot, or Mermaid diagram

Deep-zoom into a specific component for a detailed 'day in the life' view

Calculate and visualize service karma scores and dependency debt across the factory

Generate a creative multi-chapter narrative report of the factory's architecture

Run 'what-if' failure scenarios to see how the architecture handles failures

Analyze the current backend project and launch the pixel factory visualizer at localhost:7777. Use when the user says "visualize backend", "show architecture", "factory", "backend factory", or wants to see their backend as a visual diagram.

Shut down the Backend Factory visualization server

Visualize how the factory handles load with simulated traffic patterns

Generate a time-lapse visualization of architecture evolution through git history

Trace a specific API route, worker, cron job, webhook, or event flow through the backend and visualize its complete path