AI Platform · Multi-Agent Systems
A multi-agent platform that turns a natural language prompt into a production-ready full-stack application, and code a human can still maintain afterwards.
Engineers led
Across AgentX and client product lines
Fewer integration issues
From clear service boundaries and ownership
Complete
Shipped and generating applications
AgentX generates production-ready full-stack applications from natural language prompts. It is a multi-agent system built on LangChain and FastAPI, where specialised agents handle planning, schema design, UI generation and tool orchestration rather than one model attempting everything at once.
The interesting problem is not generation. It is the gap between an abstract requirement and a concrete database schema and component tree. A prompt like “let users book appointments” implies entities, relationships, states and screens that nobody stated, and getting them wrong compounds through every file the system writes.
I built the integration layer: Figma-to-code, Supabase provisioning, and MCP tool orchestration. The constraint I designed against throughout was maintainability: generated output that a human team has to inherit is only valuable if it looks like code they would have written.
Mapping abstract natural language onto concrete database schemas and UI components without inventing the wrong model.
Structuring autonomous agents so their outputs compose into one coherent application rather than conflicting fragments.
Generated code has to be readable and ownable by an engineering team after the agents finish.
Specialised agents sit behind one orchestration layer, so every decision belongs to a stage you can inspect rather than a single opaque generation.
How a specification arrives
Narrow agents, one shared plan
Where agents act on real systems
A running app, not a code dump
Each agent owns a narrow decision. Splitting the work this way is what makes the output reviewable, because you can point at the stage that got something wrong instead of re-rolling the whole generation.
The system accepts a written prompt or an existing Figma design as the starting specification.
Requirements are decomposed into entities, relationships and screens. This is the step that decides whether everything downstream is coherent.
Concrete database schemas are derived from the plan, with relationships and constraints made explicit rather than implied.
Separate agents generate backend services and UI components, each working within the shared plan.
Agents call real tools through the Model Context Protocol, so they act on actual systems rather than describing intentions.
Supabase resources are provisioned and the generated application is assembled into a running, reviewable preview.
Agent framework
LangChain multi-agent
Narrow, specialised agents produce reviewable output; a single generalist agent produces something no one can debug.
Orchestration API
Python FastAPI
Keeps the platform in the ecosystem where LLM tooling lives, with a fast typed service layer around it.
Tool access
Model Context Protocol
A standard interface for agents to reach real tools, instead of bespoke glue per integration.
Backing platform
Supabase
Generated applications get real auth, storage and a database provisioned automatically rather than stubs.
A working multi-agent platform generating full-stack applications from prompts.
Existing designs become a valid starting specification, not a manual re-draw.
Agents operate real tools through a standard protocol.
Architecture standards and service boundaries that cut cross-team integration issues by over 50%.
If any of the problems above look familiar, I can help, whether that's a full architecture or a second opinion on the one you have.
Open to remote and hybrid work worldwide