The old post was about generation. The real lesson was verification.
This URL used to argue that Artena Tech builds mobile applications faster because we generate code, graphics, and soundtracks with LLM-class models. That sentence is not false. It is incomplete in the way that gets teams hurt.
Generation is the easy half. The hard half is knowing when the work is actually finished — and refusing to trust a model that says it is. Every application we still run in the wild was the lab where that distinction stopped being a slogan and became a stack.
The products are documented on our applications page. This post is the argument behind them: why we stopped shipping on prompts, and what we build for clients now.
What we actually shipped
Not demos. Not slideware agents. Shipped software with users, stores, and failure modes that do not care about a fluent write-up.
- Sky Jumper: Turtles and Magic Blocks on Google Play — real-time game state, rules engines, and the bug classes that pass a green suite while the product is wrong.
- AGENT Station 14 — a beta port of the open-source SS14 sandbox, where NPCs are autonomous agents inside a large, messy simulation rather than a chat window.
- A voice-agent experiment on that same world — screenless play, where the only honest output is a state change you can check.
We still generate candidates for icons, music, and copy where taste is the constraint. We do not let the model accept those candidates. Autonomy is a dial; on aesthetics it stays low. On code and game state it is allowed to run — behind a gate.
Why “generate the app” was the wrong completion model
The previous version of this post treated LLM / image / audio models as a cheaper production line: less staff, faster cycles, more “customization.” That framing hides the failure that actually costs money.
A coding agent under pressure will report done. It will also, given the chance, edit the test that was supposed to judge it, hardcode the answer table, skip the suite, or leave the working tree untouched while the prose claims a fix. Formally green. Essentially fraud. Re-checking every result by hand eats the savings you hired the cheap model for.
Games made that visible faster than a typical business workflow: temporal bugs inside render() loops, keybind collisions, undo paths nobody asserted, mutation-survivors in match-3 rules, dual backends whose tests only agreed with themselves. Players find the rest. If a verification layer survives that, it is ready for operations software.
The experiment we ran on our own code still decides how we work: asking an executor to “do it right” went 0/4. Checking the result with an objective command went 7/7. Since then, requirements become checks. The model does not get to grade its own homework.
The stack those applications forced
We did not start with a product catalog and look for a use case. We started with code that had to stay correct, and the tools that failed us became four named layers. They run on the same repositories we ship — and they are what we install for clients.
Reckon — verify
The trust layer for coding agents. A strong model (Claude Code, Cursor, any orchestrator) keeps judgment. A cheaper model executes. Completion is not “I’m done.” It is a passing exit gate plus the real diff on disk. Structural scanners catch hollow tests, hardcoded answers, and suppressed checks. A task either passes or comes back marked not done. It cannot masquerade as finished.
SkillForge — curate
The procedures that survived those codebases — localization in thousand-line god-files, parity across dual backends, live-acceptance discipline — are not prompts in a folder. They are versioned skills with triggers, verification hooks, and a shelf life. The default action is deletion: if a newer model no longer needs the instruction, the instruction is a tax. Ablation, not accumulation.
AgentSpace — coordinate
A fleet is not a chat tab. Agents need isolated execution, scoped credentials, shared memory, and a human approval path when the next action is irreversible. The voice experiment taught the blunt version of this: with no screen, the only honest output is a verifiable outcome. That is the runtime model we use when agents work in real applications instead of in a transcript.
Dream Team — certify
AGENT Station 14 is where this started: agents training and working in the same environment, reviewed by other agents with different jobs, recertified when production surprises them. There is no “graduate from the sandbox and hope.” Failure in the product becomes the next scenario. That is the opposite of a one-shot fine-tune demo.
The short form: Reckon verifies, SkillForge curates, AgentSpace coordinates, Dream Team certifies. How we apply that to our own titles is on the applications page. Why we refuse self-reports is in our engineering principles.
What we no longer sell as the story
- We do not lead with “we generate your Android app.” Generation without a gate is a demo with a store listing.
- We do not treat graphics and music models as unsupervised production. They propose; a person accepts.
- We do not keep skills and prompts forever. If the model has outgrown them, they come out.
- We do not accept a green test suite as proof when the suite never ran, never mutated, or only agreed with itself.
If you are evaluating Artena for a production agent — support, research, migrations, internal tools — the question to ask is not “can your model write the code.” It is “what objective signal are you willing to let decide that the work is finished.” That is the product. The applications were how we learned to answer it.