The Agent Paradise Standards System (APSS): encoding best practices as executable, self-validating standards, so agents run repetitive work on deterministic rails instead of stochastic inference.
In my experience working with coding agents, there are many patterns I have to re-explain over and over. Even though it can be frustrating and important details may slip through, it's understandable because every agent session starts fresh unless it has context. A rule of thumb I've heard for this is the Third Time Rule: if you have explained the same thing to an agent three times, turn it into a reusable skill.
It is a good rule, and it captures the reusable workflows you lean on regularly. But from an engineering perspective, reusability is only half the story. If we want to scale, performance matters too. We want the most out of the hardware we are paying for.
A reusable skill helps, since many agents can run the same pattern in parallel. But it still runs on inference, and inference is expensive.
So what if we could turn a repeatable workflow into a deterministic script?
The slide and the Galton board #
The mood right now is "AI can do it, just prompt it." For genuinely new work, that is the right instinct. Inference is the first tool we have ever had for the parts of software that used to require a human to sit and think.
But inference has a shape. Picture a Galton board, the pegboard you may know as Plinko. Drop a coin at the top, it clatters through the pins, and it lands somewhere in a bell curve. Same input, different output. That is inference, stochastic by design. And every bounce is a little piece of work: the more the coin ricochets, the longer it takes to settle. In a real machine that maps to compute, and compute is time and watts.
Now picture a slide. In at the top, out at the bottom, one path, every time. That is deterministic code. A Rust binary, a script. The oldest guarantee in computing, and once we got excited about inference we half forgot we still had determinism. One path means less work: less time, fewer watts.
Most of what we ask agents to do all day is not new. Validate this file. Generate that scaffold. Check the config against the contract. We keep sending those coins through the pegboard, paying in watts, tokens and trust for a probabilistic answer to a question that usually has a deterministic one.
The Agent Paradise Standards System is our bet on the deterministic path. APSS, for short. The one-line version: standards that are code.
Smart standards #
A standard in APSS is built around an artifact with a shape. You pin that shape down as a schema, a protobuf contract, and that schema becomes the single source of truth. The standard itself is a Rust crate, chosen for determinism and speed.
Two kinds of code hang off that one definition: a generator that produces the artifact, and a validator that proves a given artifact conforms. And because everything hangs off the artifact, a substandard can add its own generator that reads it and produces something new, a view or a report, without touching the standard that created it.
Generation and validation from one definition reinforce each other: the standard produces things in the correct shape and proves things are in it, from the same source of truth. That is why I call it smart. The standard is not a description of the rule, it is the rule, executable in both directions.
The meta-standard #
If standards are code, then the rules for writing a standard should be code too. So APSS has a meta-standard: the standard that defines how every other standard is structured, and validates them itself. A convention only humans enforce tends towards degradation if continuous attention is not paid. A convention the tooling enforces cannot, because nonconformance is a failing build, not a forgotten guideline. Standards are versioned like software. All of V1 stays backwards compatible, and if you need to break that contract you owe the ecosystem a V2. A standard can also have substandards: smaller standards built on the parent's artifact, versioned on their own timeline.
CodeCity is a good example of how that layers. The Code Topology standard analyzes your codebase into a topology artifact, a language-agnostic snapshot of structure, complexity, and coupling. A visualization substandard then consumes that artifact and renders it. CodeCity, the 3D-skyline view I wrote about earlier, is one of those renderings. So the parent generates the artifact, and the substandard generates a view from it.
Each standard also carries its rationale, the why and not just the rule. That turns a standard into an argument you can agree with or challenge, and it turns the whole system into a lab: an idea starts as an experiment and gets promoted to an official standard only once it has earned it.
The payoff is speed, watts, and confidence #
Put it together and you get something like procedural memory for agents. The practices we would otherwise re-explain every session become executable, reusable across codebases, and wired straight into CI. Humans define the standard, agents execute it. And a green check means the artifact conforms to the standard, deterministically, which inference never promises. The validator itself still has to be correct, but that is a cost you pay once, not on every run.
Then there is the cost, and this is where it stops being philosophy. All computing is, at bottom, a power problem. Take something agents get asked to do all the time: understand a codebase.
Point APSS at a repository and it computes the whole topology, every module, its complexity, how it all couples, in about six seconds and roughly a hundred joules. 1 To get the same map from a model, you have to feed it the code, and this repository alone is around 700,000 tokens. Even a single long-context read runs on the order of a hundred thousand joules,
about a thousand times more, and the model's map is a guess where the analyzer's is exact and identical every run.
2So a kilowatt-hour buys you tens of thousands of deterministic codebase maps, or a few dozen from a model. And that is the conservative case: a real analysis is not one read but an agentic loop of them. As models get more efficient the gap narrows, but computing beats inferring here for a plain reason, the analyzer runs a fixed, small amount of compute, and a model runs a great deal.
Honesty over a tidy number. The two sides are measured differently, a laptop CPU figure for the analyzer against a datacenter estimate for the model, and both move with the task. Read it as an order of magnitude, not a precise ratio, and note that a real agentic analysis only widens the gap.
None of this is an argument against inference. It is an argument about where to spend it.
What you can do with it #
The rule the whole system compresses down to: if a task is repetitive and has a checkable shape, do not infer it, encode it. Encoding costs something up front, the schema and the code around it, so the payoff is in repetition: the more often the check runs, the more that fixed cost amortizes toward nothing.
Try it: point an agent at theCodeCity APSS runbookand have it render your own codebase as a CodeCity.Adopt it: install the CLI withcargo install apss
. It isopen source, MIT, and the artifact shapes are open contracts you can build against.Contribute: thecontribution guideis simple and agent-friendly. New standards start as experiments, scaffolded and self-validating from the first commit.
Footnotes #
Measured locally, 2026.
apss run code-topology analyze
over the APSS codebase (121 files, 2,145 functions; Rust release build, Apple M1) took about 6.4 seconds, roughly 100 joules at an estimated 10 to 20 watts. Wall-clock is measured; energy is estimated, so treat it as an order of magnitude, not a lab figure.↩ - The APSS codebase is about 700,000 tokens (its source characters divided by four). Reading that many tokens in a single pass runs on the order of 100,000 joules, extrapolated from measured per-token inference energy (the
ML.ENERGY leaderboard, roughly 0.1 to 0.5 joules per token) and Google's disclosedper-prompt energy. A realistic agentic analysis makes many such calls and costs more. This is an estimate, deliberately conservative.↩