A Month of Arcanada: What You Can Build on a $200 Claude Subscription and a Puzzle of Thousands of Pieces

A Month Ago I Launched This in Public

Exactly 36 days ago, on April 13, 2026, I renewed a Claude Code Max subscription for $200 and promised to report on the work openly. The project was launched in public — I took on the obligation to show results and share costs, to either surprise the people watching or honestly disappoint them.

Last week the subscription renewed for the second time. So I sat down to write this report — without makeup, with numbers and links to repositories. There will be a lot of numbers below: how many tasks were closed, where the money goes for infrastructure and models, what exactly I managed to build, and where I failed.

Up-front caveat: the visible result doesn't impress me very much either. The bulk of the work this month went "under the hood" — into infrastructure, LLM connectors, the development framework, and the orchestrator. You can't touch it from the outside. I'll try to explain why it matters.

What Was Built

The Arcanada ecosystem registry now holds more than 20 projects — 21 prefixes in the task registry, plus Datarim itself. Ten of them are already running in production or open to the public:

• Auth Arcana — single identity for the entire ecosystem (OIDC, Passkeys, MFA, federation with Google/GitHub/Apple/Microsoft plus Russian providers).
• Model Connector — a single bus to LLM providers (Claude, OpenAI, OpenRouter with Grok routing, local models).
• Munera (muneral.com) — a task tracker designed specifically for AI agents (but humans can use it too).
• Scrutator — vector search plus graph knowledge on BGE-M3, the memory backend for the whole ecosystem.
• Support Center, Ops Bot — operational services for tickets and monitoring.
• Transcribator (transcribator.com) — a commercial transcription product.
• Verdicus (verdicus.app) — a macOS assistant with its own API.
• Datarim (github.com/Arcanada-one/datarim, MIT) and Coworker (github.com/Arcanada-one/coworker, MIT) — two open-source projects.

The main focus of the month is Datarim. A development framework on top of Claude Code, compatible with Codex CLI, already close to SOC 2 security standards. That matters for anyone who wants to run it inside a corporation. Over the month, dozens of minor versions shipped, plus one major. The most significant change: I added an orchestrator that drives automated code development.

Honestly: I didn't get the orchestrator to autonomous operation in a month. Most of my time now goes into tuning it correctly — new rules, skills, behavior in stalemate situations. That was the main bottleneck of the month, and I'll come back to it in the "What I Learned" section.

The second focus — Arcana CLI. A custom command-line agent in Rust, under MIT. Structurally similar to Claude Code, but with three differences. It can orchestrate remote sessions of other agents: launch Claude Code, Codex, Cursor and work with their output. It has built-in memory: file-based, or through a Scrutator server (vector search and graph knowledge). And it integrates with Munera out of the box: proper handling of tasks, sprints, and projects is built in, not bolted on.

The third focus — Coworker. A tool that distributes load across multiple LLM providers. After Claude's limits started biting, it would have been expensive without it. I plugged in Moonshot Kimi, DeepSeek v4, OpenRouter (Grok). Already open-source under MIT: github.com/Arcanada-one/coworker. Additional token spending this month grew by roughly $30, after Kimi was connected.

Today, on the day of this publication, I also started two new projects in the ecosystem registry. The first — Adsessor: a commercial AI assistant for Zoom and Google Meet calls. It joins the call, produces live subtitles with translation for the host; in later phases — speaking AI agents with the roles of Architect, Business Developer, and Lawyer, fed by the shared Arcanada knowledge base (Teams and SIP are planned too). The second — Legal Arcana: a legal-document hub for the ecosystem with versioning and multi-jurisdiction compliance (GDPR, CCPA, LGPD, Russian 152-FZ, Kazakhstan Law 94-V), cross-linked with Auth Arcana through a user-consent registry. Inside it, Legal Consul — an AI agent that audits legal pages of ecosystem sites and accompanies document updates. Both are still in the PRD stage; I mention them here to mark the start date.

Datarim Numbers

I wanted to give dry statistics: how many tasks specifically were closed in Datarim over the month, in which projects, at what complexity. Here they are.

Most archives are mid-size Datarim tasks (L2, 2–8 hours: 93 archives in the main workspace), followed by L3 (44) and L1 (56). Only 6 L4-level epics closed this month: I deliberately broke big chunks into smaller ones, so the orchestrator could learn on short cycles.

The distribution by top-5 prefixes shows where the time went:

So TUNE+INFRA+CONN = 241 archives (40% of the month) — all foundation work. It gets easier from here.

Economics

Claude Code Max subscription — $200. That's the base. But one subscription wasn't enough.

Half the spending — AI models ($237), half — infrastructure ($233). The main thing to understand here: 24 machines. This is not "$200 on AI experiments." This is a working production fleet: proxy servers in multiple countries, websites, databases, dev and prod environments.

When I checked my DeepSeek account before publishing this article, the remaining balance was $2.35. That almost exactly matches my sense of "~$2 a month." Moonshot Kimi balance $14.08 USD, account enterprise-tier-2. OpenRouter has a $40 top-up cap, $28.38 spent over its entire lifetime (mostly April experiments with Grok routing for transcription). The numbers from the transcript and from the APIs converge.

And here's what the hosting bill looks like. €216.16 is exactly those 24 machines:

What I Learned

Work on Arcanada feels to me like assembling a puzzle of thousands of pieces. First you find groups of similar fragments and stack them into cohorts. Gradually those groups connect to each other, and a general picture appears. I understand that for you, reading scattered posts, this general picture is still unclear. Sometimes my posts look like the ramblings of a madman. That's a normal stage — I had it myself in the first two weeks.

The main lesson of the month — the orchestrator is the hardest part. One decision in code — tens of seconds. One decision about process — hours of fine-tuning. How to move on when a task gets stuck. How to rephrase a question to which the agent replied "I don't understand." How to escape a stalemate where several tasks are mutually blocked. How to react to a network outage at the LLM provider. Every such decision needs to be sewn into the rules so the orchestrator doesn't "forget" it on the next step.

The second lesson — coworker turned from "nice to have" into mandatory. When one provider's limits start biting — you need a second. When the second's bite — a third. A simple shell tool that picks a cheap model for bulk I/O and reserves the expensive one for reasoning saves tens of percent per month. That's why it's open-source: people with the same workflow pattern will find it useful too.

The third lesson — infrastructure-heavy work is invisible from the outside. Over the month I rolled out a mesh of 24 machines, set up auto-deploy, inter-network, buckets, backups, SSL certificates, firewalls. From the outside this looks like "a few placeholder sites and a couple of Telegram bots." From the inside — the foundation everything else will stand on.

The fourth lesson — open-source along the way. Datarim and Coworker are already on GitHub under MIT. Not about stars and not about community. About honesty: the code the ecosystem runs on should be verifiable.

What's Next

"The general picture is still unclear for you" — agreed. Let me give three concrete reference points for the next three Claude subscriptions: a horizon to mid-July.

First — the first commercial projects. I won't name them in advance, not to jinx them, but they're already sitting in the backlog and tied to working components of the ecosystem.

Second — autonomous agents you can actually touch. Not "in principle they could." Run one and see the result: async tasks in the background, recovery after a provider's network outage, the assembly of a whole project from a single prompt — from PRD to deploy.

Third — the Arcana CLI release. It currently sits in a private Rust repo under MIT. Once the main scenarios stabilize and I've tested them against my own tasks — I'll release it publicly.

All of this — within the current economics of ~$470 a month. If it works out, in July I'll be able to show you not "look, I closed another infrastructure task," but a working product that does something on a person's behalf.

Where to Look

• Ecosystem site: arcanada.ai
• Project status dashboard: arcanada.online
• Agent roles and architecture: arcanada.ai/en/agent-roles
• Datarim framework (MIT): github.com/Arcanada-one/datarim
• Coworker CLI (MIT): github.com/Arcanada-one/coworker
• Munera (task tracker for AI agents): muneral.com
• Transcribator: transcribator.com
• Verdicus: verdicus.app

If I disappear for a while — don't lose me. I haven't dropped the idea. I've just dug very deep into the guts of this ecosystem. A month ago this was a promise. Today — 597 closed tasks and 24 live machines. From here on it gets more interesting.