Generation runs as a phased plan. The agent drafts an application blueprint, generates it in stages, runs it, and reads the results before deciding what to change. Loop and completion detection stop it from re-editing the same file or declaring the app finished early, and a separate debugging pass reads runtime errors, screenshots, and console output before proposing a fix.

Every preview is a container with its own lifetime and credentials. Preview access uses revocable tokens validated independently of the management API, and the port a preview exposes is bound to a signed token, so a guessed URL reaches nothing. Prompt-injection defenses treat generated content and third-party text as data. Rate limits are enforced on two separate backends so a burst of requests cannot exhaust a single store.

Generated apps act on behalf of their owner. Access grants decide which shared services an app may call, the owner’s credit balance pays for its AI usage, and hosted form submissions become tagged CRM records for the owner. The builder exposes the same operations over MCP with OAuth so other agents can drive it, and each project’s code lives in a Git repository the owner controls.

Quality is measured. A benchmark harness builds a set of reference apps, opens each one in a real browser, exercises its workflow, and records source snapshots, screenshots, errors, and timing. The same runner replays earlier scenarios after a follow-up edit to catch regressions, and static analysis plus an automated review run on every pull request.

Each greeting is a resumable job with explicit stages: lyric drafting, song generation, character video, finishing, and delivery. Credit checks happen before every paid stage, and a job that fails or resumes keeps the outputs of completed stages so nothing already paid for is repeated. Web and native clients share the same TypeScript contracts for creation steps and job states.

Video rendering runs on a GPU fleet with a control plane. Workers send heartbeats and claim jobs matched to their capabilities; leases expire when a worker disappears, attempt counters bound retries, and four priority tiers keep interactive customer work ahead of batch rendering. The fleet spans private GPU hardware for baseline capacity and cloud-hosted serverless GPUs for overflow, and failover between them is a deliberate operator decision, which keeps a local outage from turning into a surprise bill.

Timing is deterministic. A performance-window algorithm aligns the generated video to the first reliable sung lyric, plans holds, crossfades, and secondary footage around it, and a single finalizer produces the canonical output so two renders of the same job agree.

The singing performance is generated as video from the selected character artwork and finished song. The renderer uses the character image as a reference and the song audio to drive the performance; the finishing pipeline aligns the result to lyric timing, adds captions and branding, and produces the shareable video. Supported custom-character generations can use a customer-uploaded reference image through the same video-generation path. Synthetic production monitors place a real order on a schedule and alert on any stage that stops completing.

Delivery is queue-based and per destination. Each account has its own schedule, receipts, and retry state, so a partial failure is reconciled against what actually went out. Durable Objects coordinate provider rate limits per account while separate queues handle publishing, media, and webhooks.

Agents get the same controls as people. Any agent-initiated action goes through a prepare, approve, execute sequence: the prepared action is fingerprinted, a person approves it, and a short-lived one-time token authorizes exactly that action once. The scheduler, API, TypeScript SDK, and MCP tools all enforce the same approval rules.

A media service handles the work a serverless runtime cannot. It detects musical downbeats, scores candidate cut points by harmonic and loudness continuity, optionally compares video frames across the seam, and renders exact loops with FFmpeg. Its jobs use scope-restricted leases so host-side work and container work never claim each other’s tasks.

Adaptive campaigns can rank approved clips using verified performance evidence; that capability is gated separately and rolls out per account. Publishing, inbox, and analytics coverage are verified per provider before they are offered.

The assistant answers from the same approved knowledge as the help center. Articles move through draft, publish, index, and ready states; publishing writes to a durable outbox that indexes the content asynchronously, and a retrieval allowlist decides whether an article may reach customer-facing or internal-only conversations.

Retrieved text is treated as data. Web results, site grounding, and support articles are fenced inside the prompt with explicit instructions that nothing inside the fence can change the assistant’s rules, and uploaded documents are fenced the same way. The contract test suite asserts these fences on every change.

Spend is reserved before generation. Each scope has an AI budget; a reservation is taken when the conversation starts a model call and settled afterward, and when the allowance is exhausted the conversation hands to a person with the transcript, lead details, and customer history attached. Tool calls and model calls record execution traces with timing and token usage for review.

Jaxia also runs a shared work board. People and agents claim the same work items; agent claims carry capability tags, leases, and heartbeats, delegation depth is limited, and outcomes hand back through the same records people use. The web widget and the Expo client reuse one set of support APIs and one conversation history.

Every comparison is a measured run. The application streams responses from several providers at once, records tokens, latency, and credit cost per response, and keeps text already shown to the user if a stream fails midway. A launch gate requires a model to both respond and settle usage before it is offered.

Blind Arena shuffles the model order with a stable seed so a reload cannot reveal who wrote what. Shared comparisons retain the result metadata needed to inspect a run later.

Benchmarks drive routing. An intake process scores models across dimensions, an automated judge grades answers for accuracy, reasoning, and clarity, and a routing engine compiles those scores into a versioned table. The router classifies each request deterministically, without calling a model, and selects the cheapest option that clears the quality floor for that request’s dimensions, returning a fallback chain and the savings against the frontier model. The shared AI gateway consumes the published table for its automatic model aliases.

A leaderboard publishes the current scores, and a soak harness exercises the realtime path under sustained load before releases.

Audio is bidirectional and streamed. Live calls connect over WebSocket to streaming speech recognition and generated voice; playback stops the moment a caller interrupts, and the agent keeps its context across the interruption. Recording consent, do-not-call lists, quiet hours, and two-party-consent jurisdictions are enforced by a compliance policy before the agent speaks.

Call minutes are metered like AI tokens. A credit reservation is taken when a call starts and committed or rolled back against the carrier’s final call status, and every usage event is deduplicated so a repeated webhook cannot bill twice. Missed calls trigger a text-back with the same duplicate protection.

Agent actions carry approvals. Transfers, bookings, and outbound follow-ups go through the same prepare, approve, execute controls as the rest of the platform, and each call produces a transcript, summary, and structured outcome that flows into support and CRM records. REST and MCP expose calling to other applications and agents. Voice output is tiered across providers so a business chooses the balance of cost and naturalness.