Out of LLM credits? You still get things done

AI agents wired like a circuit board: components, connections, fuses, signal.

component one single job component one single job component one single job connection connection fuse the signal only crosses a connection if it opens — and the fuse cuts without asking

The scenario

Your credits on an expensive paid model hit zero. Not figuratively: the balance was empty, in the middle of a task. Two options: put the project down, or find something else. I tried something else. It works. Here is how.

The first lifebuoy: opencode and free credits

The right reflex is not to buy more credit — it is to switch to a tool that never cuts you off. opencode, a command-line tool for driving coding agents, accepts engines other than the best-selling one. Several of them run on free credits and give decent results:

Wailing about the outage does nothing: I switched almost exclusively to Google Gemini — not only for quality, but because I take part in Google hackathons: better to be in phase with the ecosystem that helps us. And I tested Gemini with the tower — the result is magnificent.

The good news: the tool reads the same memory as the previous one. opencode is configured to read the very same instructions file as the first instruction reader — the one holding house rules, current state, guardrails. Everything we had learned on the project is reused as is. You change engines, not memory.

What really keeps me going: a good architecture

The model, even free, is not the solution — it is the last resort. A good architecture means you only wake the model rarely. Here is the one of my home agent, Alice, and why it survives every "no more credit":

  1. The map first. Before anything, Alice consults the living map: the survey of what really exists in the system. If the answer is there, she answers without thinking. Zero calls.
  2. Memory next. A small notebook keeps already-learned procedures. If it is there, you unfold it. Zero calls.
  3. Tools. Reading an image, listing a folder: gestures, not reasoning. Zero calls.
  4. The model, last. Only when the first three do not know.

Alice's model is a small qwen2.5-3b-instruct (2.1 GB) running on a home machine, served locally. She is slow — but she costs nothing, and something that costs nothing can run forever.

Probably the most surprising part: working this way is not a poor fallback. It is the right order. When you have credit, you tend to call the model for everything, even for what you already know. The constraint put the questions in the right order.

What if tomorrow everything becomes paid? We run Alices

The warning at the start is not a joke. Today's "free" models can become paid tomorrow. But the architecture cannot be switched off: the map, the memory, the procedures, the tests — all of that lives with us, not in a cloud.

When one engine becomes paid, you switch. And if all become paid, we run Alices: fully local agents, local brain included, that have already proven they learn, play and answer without any subscription. The home machine handles all of that on its own.

How to build an Alice, in seven pieces

The project is called Alicization. Every piece is simple and testable:

  1. The router — the train switcher. It applies the order above: map, then memory, then tools, then model.
  2. The living map — a file describing what exists. Alice re-reads it on every request, no restart needed after an edit.
  3. Memory — a small local database keeping learned procedures, with keywords and steps.
  4. The eyes — an image reader: show her a screen, she reads it.
  5. A brain that learns — Q-Learning: trained on a grid, she learns to reach a target, and her policy is exported as a "circuit".
  6. The heart — she detects the mood (tired, lost, happy, frustrated) and adapts her tone, with no external service.
  7. The body — a home-made 3D game, a dungeon where she drives the avatar through the real engine (walls, collisions), with measured proof: before/after, the avatar moved.

Installation fits in one command: a script installs the system packages, the dependencies, checks the tools, then runs the project tests. Another one starts everything — API, map, game — without restarting what is already running. And every capability arrives with its test written first, doors that can say no, and proof measured after.

Privacy: what we send to the models

Switching to a local or free model does not change a basic rule: you must state explicitly to the LLMs that you do not want them to train on your data on their machines. It is not automatic — a « no training » clause must be spelled out yourself, otherwise the grey line remains.

All the engines mentioned do not carry the same risk. In my case, big-pickle was a known and accepted risk: the project is open source, so what is discussed there is public by nature. But for real infrastructure and architecture, I favour the LLMs of the big players: Google (Gemini), Anthropic (Claude), Microsoft (Azure OpenAI), DeepSeek and OpenAI (GPT) — the ones I have tested so far. Their enterprise contracts let you explicitly lock in the no-training on your data.

The takeaway

When the credits stop, it is not the end of the work: it is the signal that you were depending on the wrong thing. Having credits is comfortable — but getting by without them is the real robustness. You survive the hardest day by switching engines, and more durably by cutting down how often you call the model at all. And if one day all engines close their doors, we run Alices: local agents, brain included, that need no subscription at all. This is not an emergency plan — it is the fallback you never give up. When you have it, running out of credit stops being an outage.

To remember: the model changes, the memory stays. Published on September 1, 2026.
🔭