The "single prompt" is the headline. The production reality, for now, is wiring.

Google's I/O demo of agents on Gemini 3.5 Flash building an OS for $916 "from a single prompt" is making the rounds. Independent analysis suggests that single prompt is actually thousands of lines long, layered with role-specialised sub-agents and a dedicated cheat-detection scaffold.

I already have Antigravity running its first real assignment for me — a unified web interface across my Claude, Gemini, ChatGPT, and Grok subscriptions, with a local LLM on top acting as the summarisation and judging layer. Spark hasn't opened up for my account yet. I'll write a separate post once I've actually worked with both.

For now, let's talk about what's already shipping in production.

Agents are coming. I genuinely believe that. But anyone who has tried to deploy fully autonomous loops in enterprise environments knows the friction: they drift, they fall into tool-calling loops, and they can quietly burn through hundreds of dollars in API credits while convinced they are doing great work. They are brilliant in demos, but not yet at the level of quality you need for a production system.

What actually works today, and works surprisingly well, is a symbiosis between LLMs and "pre-agent" technology:

The Trigger: A scheduled job (cron) or an incoming event fires off the work.

The Context: A small script gathers the necessary data. This includes a strict RAG step over a curated golden source, keeping the LLM grounded in facts rather than its own priors.

The Logic: One or two focused AI calls do the narrow cognitive work — reading messy input, extracting metrics, summarising, or reranking.

The Execution: A script takes the structured output and executes the exact side effects.

That's it. The whole contraption runs unattended for weeks. It doesn't drift, it doesn't loop, and it doesn't surprise you with a massive bill.

People sometimes call this "less ambitious than agentic." I think that's exactly backwards. This is the exact same problem the agent crowd is trying to solve, but built out of deterministic code instead of non-deterministic AI.

The cron job stops the loop. RAG keeps it honest. Scripts enforce boundaries. The LLM is simply a component doing what it does best: making sense of messy human input.

And then there is the cost of usage, which is starting to get strange.

$916 for an operating system sounds cheap next to a human engineering team. But the underlying pricing model is genuinely odd.

Right now, you can pay $20–$200 a month for a coding tool like Cursor or Copilot and prompt it all day long. Spend that same $200 directly on raw API calls, and an active agent loop can burn through it in a single working day — sometimes in hours, if it gets stuck.

This isn't a sustainable equilibrium. It's a market-share subsidy. The cloud providers are eating the margin, and it's a question of when, not if, the bill starts to reflect the true cost of compute.

From my own experience, two recent examples:

Example 1. I asked a Hermes agent connected to the Gemini 3.1 API to migrate a data extraction pipeline from one server to another. Perfect job for automation: read the documentation, inspect the old setup, replicate it on the new server. I wrote a prompt with clear implementation logic, the agent picked it up quickly, figured out what needed to move (scripts, cron jobs, dependencies), and replicated almost the entire folder structure and setup. But it failed on the final adaptations and got stuck in an infinite loop trying to read something from the terminal that wasn't there. I was watching and stopped it. Most of the work was done. Cost: $12 in API calls, about 3 million tokens. A manual migration would have taken me over an hour, so still a win.

Example 2. Building a simple injection script between AWS and a local-server agent on Gemini 3.1: done in seconds, cost $0.17. Not even comparable to human software development costs.

In both cases, I was checking each step the agent took — which also took my time. So the current line that "AI won't take your job, but someone using AI will" still holds. Although after watching Google's I/O presentation, I'm a little less certain that humans will stay part of this equation.

This leaves us with three hard questions:

How long does the gap between flat-rate subscriptions and raw compute API costs hold?
If you build a product on agent APIs today, can you precisely predict its development or maintenance costs?
As the enterprise piles in, what happens when GPUs and data-center power grids hit their absolute physical limits?

Nobody has clean answers yet. We're early enough that anyone who sounds certain is mostly guessing. But the direction of travel seems clear:

Unpredictable API costs, real infrastructure bottlenecks, and tightening data residency regulations are quietly pulling us toward Sovereign AI — running models locally on hardware you actually own.

Not as a rejection of the cloud, but as a flight to predictability. The parts of the stack you depend on every day, the parts you need to audit, and the parts you need to budget for — those are the parts you'll want to own.

Wiring you wrote yourself, in code you can read, with a bill you can predict.

(There's a whole separate conversation about regulation here — EU AI Act, FINMA, audit trails, data residency — and why deterministic scaffolding is much easier to make audit-ready than autonomous cloud agents. That deserves its own post. Soon.)

P.S. From the last post — artjoms.ai is still running, still fully autonomous, still local. New addition: it now generates video podcast versions of the daily briefing and publishes them to YouTube. I know... more fuel for the great AI slop fire 😉

🎙️ https://www.youtube.com/@artjomsai

#SovereignAI #LocalAI #AgenticAI #RAG #LLM #Gemini #AIGovernance #SoftwareEngineering