Build your vibe coding platform

An AI-native SaaS platform that turns a plain-English prompt into a production-ready web or mobile application: generated, tested, debugged, pushed to GitHub, and deployed without the user writing a single line of code. Alongside the code engine, Avyrix ships a full media studio, so teams can generate the app and the visual assets around it in one workspace.

The problem it solves

Going from an idea to a working product still means hiring developers, setting up infrastructure, wiring auth and databases, writing tests, and configuring deployment. Existing AI code tools help with snippets, but they stop at the editor. You still own the debugging, the repo, the CI/CD, and the assets. Avyrix closes that gap. A prompt goes in, a working, version-controlled, deployed application comes out, and the platform fixes its own mistakes along the way instead of handing errors back to the user.

How it works

1. User writes a prompt, describing the app they want, in natural language

2. Planner agent breaks it down into architecture, data schema, screens, and backend logic

3. Multi-model router picks the right brain, routing each task to Claude, GPT, Gemini, or Grok depending on what that task is best served by

4. Code generation agent builds the full stack: responsive frontend, database migrations, authentication, and backend business logic

5. Testing agent runs a self-healing loop, writing and running Jest suites in an isolated sandbox, catching failures, and re-iterating until the build is stable before anything renders to the user

6. Live preview appears in the workspace, where the user sees and interacts with the running app

7. One click pushes to GitHub, with the repo created via OAuth, code committed, and a GitHub Actions CI/CD workflow injected automatically for continuous deployment

8. Media studio fills in the assets, with text-to-image and text-to-video generation in the same workspace, no context switch

What I built

Autonomous multi-agent generation pipeline
The core of the platform: a coordinated Planner, Code Gen, and Review/Testing agent loop that plans an application, writes it, tests it, and debugs its own output through uncapped self-healing iterations. Nothing reaches the user's screen until the loop converges on a stable, error-free build.

Multi-model AI routing layer
Rather than binding the platform to one LLM, I built a routing layer that dispatches each generation task across OpenAI, Claude, Gemini, and Grok, selecting the optimal model per task type, with fallback handling when a provider degrades or rate-limits.

Vector database / RAG context engine
Integrated vector storage so agents generate against the actual codebase rather than a blank slate. Codebase-aware retrieval keeps edits consistent with existing files as a project grows. Native Model Context Protocol (MCP) support gives agents a uniform way to talk to external tools.

Cross-platform output, web and React Native
The same prompt pipeline compiles to both responsive web frameworks and fully runnable React Native codebases, downloadable and buildable in native environments.

Sandboxed QA testing agent
An isolated test runner where the AI writes and executes Jest suites against its own generated code. Test results feed straight back into the healing loop as structured signal, not raw logs.

GitHub automation and CI/CD injection
GitHub OAuth connection, programmatic repository creation and code push via Octokit, and automatic generation and injection of a GitHub Actions workflow file, so deployment to Vercel or a cost-optimized cloud endpoint is trigger-based from the first commit.

Workspace environment manager
A secure panel for setting, updating, and viewing environment variables per project, with historical build and deployment logs. This is the operational surface that makes generated apps actually maintainable.

Unified media studio
Text-to-image generation with aspect-ratio targeting, an asset library, and advanced editing: inpainting, outpainting, ControlNet formatting, model switching. Text-to-video powered by Runway ML with multi-scene composition and asynchronous job tracking over WebSockets, so long renders stream progress instead of blocking the UI.

Billing, credits, and admin control
Stripe-integrated subscription tiers with a credit deduction engine tied to real token consumption, plus an admin panel exposing agent loop telemetry, token usage graphs, content moderation queues, and integration health logs.

Tech stack

• Frontend: React (responsive SaaS workspace with live preview canvas)

• Backend: Node.js, NestJS / ExpressJS, modular service architecture

• Database: PostgreSQL with vector memory extensions for RAG

• Vector DB: Pinecone / Weaviate

• Auth: JWT, Google OAuth, GitHub OAuth

• AI models: OpenAI, Claude, Gemini, Grok (multi-model routing)

• Agent protocol: Model Context Protocol (MCP)

• Image generation: DALL·E 3 / Stable Diffusion via Replicate

• Video generation: Runway ML (Pika / Kling fallbacks)

• Version control: GitHub API via Octokit plus injected GitHub Actions CI/CD

• Testing: Jest, executed in an isolated sandbox runner

• Payments: Stripe

• Infrastructure: Docker on VPS, Cloudflare R2 / S3 storage, Vercel deployment targets

Key accomplishments

• Built an autonomous agent pipeline that plans, generates, tests, and self-heals code without human intervention, with no capped iteration count and no error dumps handed back to the user

• Designed a multi-model routing array that treats four LLM providers as interchangeable compute, routed per task and resilient to any single provider failing

• Shipped a complete prompt-to-production loop: prompt, code, tests, GitHub repo, CI/CD, live deployment

• Extended generation beyond web to fully runnable React Native mobile codebases from the same pipeline

• Integrated a production-grade media studio, with advanced image editing and async video generation, inside the same workspace as the code engine

• Delivered the full commercial layer: Stripe billing, credit metering tied to real token usage, and an admin panel with agent-level telemetry

What I learned

• Self-healing loops live or die on the quality of their feedback signal. Structured test output and parsed error traces let an agent converge in a few cycles, while raw stdout makes it wander indefinitely

• Multi-model routing is an architecture problem, not a prompt problem. Normalizing four providers' token limits, streaming formats, and failure modes behind one interface was most of the work

• RAG over a live, growing codebase needs an aggressive re-indexing strategy, because stale embeddings cause agents to confidently rewrite files that no longer exist

• Long-running generative jobs such as video renders and full-app builds demand async job tracking from day one. Retrofitting WebSocket progress onto a request/response design is far more expensive than designing for it

• Credit metering has to be wired into the AI layer itself, not bolted on at the API boundary, otherwise multi-model usage and cost never reconcile

Why this matters

Avyrix compresses the entire path from idea to deployed product into a single workspace. It is not a code assistant. It is an autonomous engineering pipeline with version control, CI/CD, testing, and media production built in. Shipping it meant solving orchestration, reliability, and cost control at the same time, which is exactly the kind of complex full-stack AI systems work I bring to every project.