Start here / one concrete request
“Create a friendly illustrated fox holding a small lantern, warm orange and cream, facing forward, with a transparent background. Make it square for my welcome screen.”
Maya is building a reading app called Lantern. Her design agent is connected to Celstate, and her account has credits. This is a synthetic example. The input is a description and shape; the desired output is a transparent PNG that can sit on any screen color.
The agent receives a completed image and a download link, then places the fox on Lantern’s welcome screen. Celstate makes and delivers the asset; the design agent handles its placement in the app.
From request to result
What happens next
-
Maya asks for a fox
Maya tells her design agent what Lantern needs: a friendly fox holding a lantern, drawn in warm colors, square, with no visible background. The agent sends that description to Celstate’s transparent-image tool. It asks for the finished asset, so Maya does not have to choose an image model herself.
What moves forwardThe agent sends the fox description, square shape and transparency request to Celstate.
How this step works
MCP is the connection through which the agent calls Celstate’s tools. Transparent pixels let the fox sit on Lantern’s screen color without a rectangular backdrop.
-
Celstate starts the job
Celstate checks which account the agent is using and whether it can start another image. Maya has credits, so Celstate uses one credit, records her fox request and schedules the work. It gives the agent a job number to check later: the request is accepted, but the fox is still being made.
What moves forwardThe agent receives the job number while Celstate schedules the image work.
How this step works
The job desk is Convex, which keeps accounts, balances and scheduled work. Unsupported input, insufficient credits, too many unfinished jobs or a paused service can stop a request before charging. Recording the job, changing the balance and scheduling work happen together.
-
Celstate asks its selected model to draw
Celstate looks up its selected model for transparent images and prepares Maya’s request in the form that model understands. It supplies the fox description, a supported square size and the instruction to return transparency. The current method asks the model to draw the fox and its empty background in one call.
What moves forwardThe external image service receives the description, size and transparency instruction.
How this step works
The model choice is maintained and dated; Celstate does not compare competing models on every request. Image size and quality are explicitly set to limit cost variation. Direct transparent generation avoids a second background-removal call, but its edge quality remains incompletely measured.
-
The agent waits while the fox is drawn
The external model draws the fox while Maya’s agent checks the job number for progress. These happen alongside each other; checking does not make the model start again. When the image is ready, the model service tells Celstate where to collect the file, and Celstate moves on to checking it.
What moves forwardThe model service returns the image’s location to Celstate.
How this step works
Checking an existing job does not spend another credit. A new generation call starts a new job and can charge again. Repeated internal delivery of the same scheduled job is guarded separately. Work that never started can be rescheduled; started work that stalls is failed and refunded.
-
Celstate checks the returned fox
Celstate collects the image and checks that it opens, is square and contains transparent pixels. If the model returned a solid background, the request fails and Maya’s credit is restored. Passing means the file meets those basic requirements; Maya still decides whether the fox looks right for Lantern.
What moves forwardA file that passes goes to storage; a failed check closes the job and restores the credit.
How this step works
Sharp is the image-processing library that reads the file and measures its properties. The transparency check catches effectively opaque output; it does not prove clean edges, beauty or complete obedience to the description. Provider, timeout and storage failures also restore the consumed credit, even if Celstate incurred provider cost.
-
Celstate saves the finished image
Celstate saves the fox in its own file store and prepares a smaller copy for web use. It then marks Maya’s job complete. Keeping its own copy lets Celstate deliver the fox without relying solely on the temporary file location supplied by the image model service.
What moves forwardThe completed job now points to a saved image the agent can download.
How this step works
Celstate also records the outcome and provider cost separately from Maya’s credit balance. Where cost is estimated rather than measured, that difference is recorded. Convex holds the job and files; the front door serves access to them.
-
The agent puts the fox into Lantern
The agent checks Maya’s job again and receives the finished image’s download link. It fetches the transparent PNG and places the fox on Lantern’s welcome screen, where the app’s color shows through the empty background. Maya reviews the result. Celstate has delivered the asset; the agent finishes the surrounding design work.
What moves forwardThe fox moves from Celstate’s file store into Maya’s app.
How this step works
If Maya later wants the fox to hold a book, the agent can make a new edit request with this image and a new instruction. Editing uses its own model route and checks, while the account, job and delivery process remain familiar.
The system behind the story
Every piece has a job
Open a piece for its role, or a technology for the choice and tradeoff.
PeopleMaya and her design agent
Maya chooses the asset she needs. Her agent turns that intention into a request, checks progress and uses the delivered file.
SoftwareCelstate’s front door
The website and agent endpoint receive requests. MCP, the agent tool connection, carries instructions and responses; it does not generate pixels.
SoftwareThe job desk — Convex
Keeps accounts, credits, job records and files; schedules work and records completion or failure.
RecordsDated routing choices
Map each image task to Celstate’s selected model and request settings. Callers name the outcome, not the model.
ServiceExternal image service
Receives the creative description, or an input image for editing tasks, and makes the pixels.
ServiceSign-in and payments — Clerk and Stripe
Clerk handles human sign-in. Stripe handles credit purchases and payment confirmation. These support the image journey rather than generate the image.
Why these technologies?
Agent tool connection — MCP
- The job
- Lets an agent discover image tools, start a job and retrieve progress or results.
- Why this choice
- The primary documented consumer is an agent asking for an image outcome through stable task names.
- The tradeoff
- The caller must support the connection and distinguish starting a job from checking one. MCP itself adds no image quality.
Web front door — SvelteKit on Vercel
- The job
- Serves the human workspace and public request routes, passing agent requests to the backend.
- Why this choice
- The documented architecture assigns the public web surface to SvelteKit and durable work to Convex.
- The tradeoff
- The front door and backend are separate services. Losing web access can block callers even when stored job records still exist.
Jobs, balances and files — Convex
- The job
- Records requests, schedules image work, keeps files and settles success or failure.
- Why this choice
- Database transactions keep account arithmetic and job state under software control, separate from creative model output.
- The tradeoff
- Backend availability affects both new work and delivery. It also cannot host the browser rendering needed by some proposed animation work.
Task routing — one stable request, a maintained model choice
- The job
- Translates a requested outcome into the selected model’s inputs and settings.
- Why this choice
- The documented product promise is that callers should not repeatedly integrate providers as image models change.
- The tradeoff
- Celstate owns the work of keeping choices good and current. A dated pick does not establish that it remains the best choice today.
Native transparency and fixed image settings
- The job
- Requests transparent generation directly, with a chosen quality level and supported sizes near a similar pixel budget.
- Why this choice
- Direct transparency uses one model call instead of generation followed by background removal. Fixed settings limit cost variation behind the flat credit charge.
- The tradeoff
- Arbitrary resolution is not a caller control. Native transparent edges remain incompletely measured, and the external image service must be available to make new assets.
Image checks and preparation — Sharp
- The job
- Reads output files, measures dimensions and transparency, and prepares delivery copies.
- Why this choice
- The documented choice keeps quick structural checks on the request path and broader quality judgments in separate evaluation work.
- The tradeoff
- A technically valid file can still disappoint creatively. Checking for transparent pixels does not establish clean edges.
Identity and credit purchases — Clerk and Stripe
- The job
- Clerk signs people into their account; agent requests identify that account through a user-created key. Stripe takes payment and confirms it to the backend before credits are granted.
- Why this choice
- The product separates account identity, payment settlement and image work. A return from checkout alone is not payment confirmation.
- The tradeoff
- Sign-in trouble affects human account access; payment trouble can delay credit purchases. Stripe is not required for each image when the account already has credits.
Product visibility — PostHog and Sentry
- The job
- PostHog shows product behavior; Sentry captures web application errors. Generation records in Convex explain image-job outcomes.
- Why this choice
- The documented system separates behavior analytics and application errors from the authoritative job and balance records.
- The tradeoff
- Losing telemetry reduces visibility. Analytics alone cannot establish payment settlement, image quality or production reliability.
Keep the boundary clear
What exists, and what comes next
Deployed image tools for people and AI agents. Animated characters remain research.
Implemented today
- Agent requests become background jobs that can be checked until complete or failed, with stored file delivery on success.
- The human workspace presents image creation and common image changes. Different outcomes take different inputs; background removal needs an image, while adding text needs an image and the exact words.
- Before acceptance, missing account access, unsupported inputs, insufficient credits, too many unfinished jobs or a paused service can refuse work without a generation charge.
- After acceptance, provider errors, timeouts, failed output checks or storage failures close the job as failed and restore its consumed credit. Celstate may still have incurred provider cost.
- Recovery distinguishes work that never started from work that started and stalled. Repeated delivery of the same scheduled job is guarded; a fresh generation call remains a new job.
- Stripe settlement grants purchased credits without granting the same purchase twice. Payments are a separate branch from image generation.
Limits of the current system
- This walkthrough follows the inspected source using an account with credits. The exact deployed revision and present service health were not checked.
- The newer web offer is committed but explicitly documented as not yet deployed: small watermarked previews, Google sign-in to unlock, two free account unlocks, then credits. The README says production still charges one credit per generation. This offer should not be described as a verified live experience.
- Structural verification checks file promises, not artistic quality. Current choices are dated routes; native transparency quality and superiority across every task category remain incompletely measured.
- Fix photo currently makes one editing call with a fixed instruction. It is not yet an adaptive diagnosis-and-repair pipeline.
Next, not yet established
- Reproducible benchmarks across the image tasks, with published evidence behind routing choices.
- Smarter photo repair that diagnoses the problem before choosing how to fix it, with a defined spending boundary.
- A full animated-character capability. Research has useful component work, but the current agent tools do not deliver the complete animated-character promise.
Say it back
The version to remember
Celstate lets an AI agent ask for an image outcome without integrating individual models. It checks the account, records a job and routes the request to its selected image model. The agent checks progress while the work runs. Celstate then checks the file’s basic promises, saves it and returns a usable link. Failed jobs restore the credit. The product’s promise is a stable image capability; proving the quality and freshness of every model choice is the next layer of evidence.
Founder questions
Check your understanding
What does Celstate add beyond calling an image model directly?
A stable task interface plus the account, routing, waiting, checks, storage and delivery around the model. The caller hands off an outcome rather than owning each provider integration.
Does it pick the best model dynamically for every request?
No. Current requests use dated choices in a routing table. Broader reproducible benchmark evidence is planned; a universal best-model claim would go beyond the evidence inspected here.
Is transparent generation the same as removing a background?
No. One makes a new image with transparency directly; the other removes the background from an existing image. They share the lifecycle but have different inputs, routes and checks.
Does passing verification mean the image is good?
It means basic file promises passed. It does not prove taste, precise prompt-following or clean transparency edges.
Can an agent keep checking after it submits?
Yes. Checking the existing job retrieves progress or its result. Calling generation again starts another job, which can consume another credit.
What happens if the model fails after the account is charged?
Celstate marks the job failed and restores the consumed credit. The customer refund does not guarantee that the external provider refunded Celstate’s cost.
Can it make animated characters today?
The full animated-character capability remains future work. Research components are not equivalent to an available end-to-end tool.