Marblism Studio

Marblism Studio is an autonomous full-stack application generator targeting the React/Node.js vertical. The core architectural philosophy is a single-prompt-to-project pipeline that collapses requirements gathering, schema design, route definition, authentication wiring, styling, and deployment configuration into one deterministic generation cycle. Unlike chat-oriented copilots, Marblism maintains a structured intermediate representation (IR) of the application: an entity-relationship model, a route manifest, and a component tree. The execution harness orchestrates multiple specialized model invocations—a high-level planner that produces the IR, a schema generator that emits Prisma models, a route and controller generator that writes Node.js service code, and a frontend generator that creates React components bound to those services. Model routing is typically gated by complexity: simple CRUD apps use a fast, fine-tuned 7B-class model to minimize latency and cost; complex multi-role applications with custom business logic escalate to a frontier model (e.g., GPT-4-class or Claude 3.5 Sonnet) with extended context. The generator runs inside an isolated container with network access for package resolution, but filesystem writes are confined to a per-session overlay. Token consumption is aggressively managed: the planner caches the IR, and each subsequent stage receives only the relevant slice plus a compact schema summary, not the entire codebase. This avoids quadratic context blowup across file-generation steps. The output is a consumable codebase (not a managed black box) with a standard npm-based toolchain, Prisma migrations, NextAuth or custom JWT sessions, Tailwind CSS, and Docker or Vercel deployment manifests. The freemium model exposes a capped number of full generations per month, with paid tiers unlocking parallel generation, custom templates, and enterprise on-prem runners. Overall, Marblism aims to compress what normally takes 40-80 developer-hours into under 5 minutes of wall-clock time for standard internal tools and MVP-grade products. The engineering trade-off is reduced architectural control: generated code follows opinionated patterns that may not fit domain-specific requirements without post-generation refactoring.

Marblism Studio's execution pipeline is best modeled as a staged, stateful multi-agent system with explicit intermediate artifacts rather than a monolithic ReAct loop. The top-level orchestrator (written in TypeScript, running in a Node.js runtime on AWS Lambda or GCP Cloud Run) receives a natural language prompt. It performs named entity recognition against a curated schema vocabulary to extract entities, relationships, fields, and access-control hints. This is not a free-form agentic loop; instead, it uses constrained decoding (grammar-constrained sampling) to emit a JSON-based Application IR. The IR defines: entities (with attributes and types), relationships (one-to-many, many-to-many), route permissions (public, authenticated, role-based), UI pages (list, detail, create, edit), and deployment target. The IR is stored in a per-session memory cache (Redis) keyed by a session UUID. Subsequent generation stages fetch the IR, not raw conversation history, minimizing token overhead.

The second stage is the Prisma Schema Generator. It consumes the entity-relationship portion of the IR and emits a valid Prisma schema file. The model is fine-tuned on thousands of Prisma schemas with correct relation annotations, index definitions, and enum usage. The generated schema is validated by a deterministic parser (prisma validate) and, if invalid, a repair loop retries with the parser's error output appended to the prompt. This closed-loop validation is the only ReAct-like retry mechanism; the rest of the pipeline is synchronous.

The third stage is the Backend Generator. It consumes the IR plus the validated Prisma schema and emits route handlers (Express or Fastify depending on the selected template), middleware for authentication (JWT verification, session cookie parsing), service classes with CRUD methods, and input validation schemas (Zod). The model is instructed to output files in a deterministic order using a tool-calling dispatch: each write_file tool call includes the full path and content hash. The orchestrator intercepts the stream and writes files to an in-memory overlay filesystem (using memfs) before committing to a persistent volume. This prevents partial writes from corrupting the session.

The fourth stage is the Frontend Generator. It receives the route manifest and component tree, then generates React components using a Tailwind CSS design system. It uses a component library abstraction (shadcn/ui) to avoid generating raw CSS from scratch. Each page component is typed against generated TypeScript API client stubs, which are also emitted. The generated API client uses axios or fetch with typed request/response types derived from the Zod schemas.

The fifth stage is the Integration and Build Verifier. The orchestrator mounts the overlay filesystem into a lightweight sandbox (gVisor or Firecracker microVM) running Node.js. It executes npm install, npx prisma generate, npm run build, and optionally npm run test to validate the generated project compiles. Build errors are fed back to the responsible generator stage with a diff context: the actual compiler error text, the offending file's content, and the IR slice. A max of two repair iterations per stage is enforced to bound cost. This sandbox has no outbound network except to the npm registry, and all generated code is scanned for common security anti-patterns (SQL string concatenation, eval calls, insecure JWT algorithms).

Token overhead analysis: For a typical 5-entity CRUD app, the planner uses roughly 2,000 input tokens and 500 output tokens. The Prisma generator uses 800 input and 400 output. The backend generator consumes 3,000 input and 3,500 output across 10-15 tool calls. The frontend generator consumes 4,000 input and 5,000 output. Build verification and repair adds 1,500 input tokens per iteration. Total per generation: ~11,300 input and ~9,400 output tokens, roughly $0.08-0.15 at current frontier model API prices with caching. The IR cache reduces repeated context by avoiding re-sending all previously generated files.

ASCII topology: User Prompt | v [Planner] --IR JSON--> [Redis Cache] | | | v | [Prisma Generator] <-- prisma validate (retry) | | | v | [Backend Generator] --write_file calls--> Overlay FS | | | v | [Frontend Generator] --write_file calls--> Overlay FS | | v v [Sandbox Build Verifier] <-- npm install, prisma generate, build | v [Output Tarball / Git Repo]

The system is not fully autonomous in the sense of long-running self-directed loops; it is a deterministic pipeline with bounded retries. This design prioritizes reliability and predictability over open-ended creativity, which is appropriate for generating standard CRUD applications.