Judges for coding agents
An AI agent that writes code already has good hands: it reads, searches, edits and runs a shell. What it lacks is a way to know an API it was never trained on, to check that what it wrote keeps its promises, and to show a change before it lands. Softanza has those three on one engine. This page shows them running, says what an agent can reach today, and describes the door that will let it reach the rest.
Hands and judges
AI coding agents such as Claude Code, Codex or Cursor come with their own tools: they read files, search them, edit them and run commands. More ways to find code help them little; they keep coming back to plain search. What they cannot do on their own is know an unfamiliar API without guessing, judge their work against rules and promises, and present a change as an intention a person can review before anything moves.
The Softanza way Softanza does not compete with the agent's tools for finding code. It supplies the judges: something that knows the API, something that checks the claim, and something that shows the change before it lands. The agent keeps its hands.
The judges, run
These run today inside the library. An agent can already reach them by writing a short script; the door described below will let it call them as commands.
Know the API: asked in plain words how to remove duplicates, the library composes the method's name from its own naming grammar, then confirms the method exists. An agent does not guess.
oDoc = StzSelfDocQ("stzList")
? oDoc.HowTo("remove duplicates")
? oDoc.HasMethod("DuplicatesRemoved")Q([...]).RemoveDuplicates() -- composed by grammar (remove duplicates) 1
run on 2026-10-02 00:46 inside the library at commit 0e72e2e2c; taken from base/education/program/courses/elementary-introduction/chapters/13-the-gap-question.en.md(opens in a new tab)
Check the code: a house rule no generic linter knows finds a real call at its line, and leaves alone a method that merely bears the same name.
aF = StzCheckCode("class Foo" + nl + "def Bar()" + nl + " x = substr(s, 2)" + nl)
nF = len(aF)
for i = 1 to nF
? aF[i][:rule] + " @line " + aF[i][:line] + " [" + aF[i][:severity] + "]"
next
? "findings: " + len(StzCheckCode("class Foo" + nl + "def substr(x)" + nl + " return x" + nl))engine-first @line 3 [warning] findings: 0
run on 2026-10-02 00:46 inside the library at commit 0e72e2e2c; taken from base/doc/narrations/stz-rules-as-graph-rules-narration.md(opens in a new tab)
Show the change before it lands: three file operations are rehearsed in a twin and come out as a plan a person can read; nothing on disk has moved.
oVfs = new stzVirtualFileSystem()
oVfs.CreateFolder("config")
oVfs.CreateFile("config/greenhouse.ini", "pump_threshold=40")
oVfs.MoveFile("old_settings.txt", "config/legacy.ini")
oPlan = oVfs.GenerateUpdatePlan()
? oPlan.Narration()Update plan (3 of 3 operations to commit): * 1. create folder 'config' * 2. create file 'config/greenhouse.ini' (17 bytes) * 3. move 'old_settings.txt' -> 'config/legacy.ini'
run on 2026-10-02 00:46 inside the library at commit 0e72e2e2c; taken from base/doc/narrations/stz-system-dev-to-deploy-narration.md(opens in a new tab)
What an agent reaches today
- Inside, the judges are deep. The library explains every method from its own source. House rules and a whole-program checker judge the code. Thousands of written promises and five hundred scenario guards state what the code must print. A change can be rehearsed and then committed through gates, and a schema can hold a local AI model's answers to a shape.
- From outside, little reaches. An agent can run a script, but it cannot yet call a command that answers, judges or plans. A failure does not yet show as an exit code, so no hook can trust a pass, and no instruction file is written for agents.
- That gap is the finding. Softanza's own review of the question rated the capability as deep and the reach as almost nil. The work is not new machinery; it is a door.
The door: one stz command
ratified proposal Decided on 2 October 2026. Not built yet. Every verb below answers from the library and the engine, never from an AI model.
stz ask · explain · howto
What a method does, its forms, an example with its promise, and where it lives. The answer comes from a catalogue generated from the source, so it cannot invent a method.
stz check
Findings as data: the rule, the file, the line, the severity and what to do. The library's house rules, the whole-program rules and the court of the declared languages, in one shape.
stz promise · guard
Each written claim, or each scenario of a guard, kept or broken, with an exit code a hook can trust.
stz rehearse · commit
The change as a plan, without touching the disk; then its commit through the gates, by someone entitled to commit.
stz do
One short program against the engine, for the work itself: text, tables, graphs, maps, statistics and diagrams, in one call and one binary.
stz grammar
The grammar of each declared language, so that an agent's sentence can be validated before it runs, and a local AI model held to valid sentences only.
Every verb follows the same laws. It answers as data when it is not talking to a person. It exits with 0 for success, 1 for findings and 2 for a refusal. It contains no AI model: the agent brings its model, Softanza brings the judgement. Every refusal says where, what, why and what to do. And the verbs stay the same whatever language the platform itself is written in.
Five ways in
- A command line. Every agent that has a shell can use it, and its answers compose with pipes.
- An MCP server. The same verbs as typed tools, for clients without a shell, held in one warm process, read-only first. The platform's application tier already serves a declared project to AI tools this way, read-only and audited, and registers itself with the tools installed on the machine.
- A skill. A page the agent loads only when it needs it, teaching which verb to use when.
- A hook. An optional check after each edit, so the agent fixes an error in the same turn.
- A plugin. One install for Claude Code that brings the skill, the hook and the server together. Other agents read an AGENTS.md file and use the same server.
Tools that know whether they may act
Every tool carries one of the platform's capability kinds: compute, sensing, inference or effect. The agent's AI model is treated as what it is, an actor that may infer and propose but not act. So a tool that computes or reads answers at once. A tool that would act returns a plan with an identifier and changes nothing. Only a person confirming at the agent's permission prompt, or a governed actor, commits that plan, and every call is recorded.
The Softanza way The difference with an ordinary tool server is not more tools. It is that every tool knows whether it may act, and refuses with its reason when it may not.
The order of work
- Make failure visible: every runner fails with an exit code when a promise breaks.
- Open the door: an AGENTS.md file and a skill that teach the verbs.
- The two verbs with the clearest value:
stz checkandstz ask. - The verbs nobody else offers:
stz promise,stz rehearseandstz grammar. - The MCP server, generated from the verbs, then the plugin.
- Measure twenty real tasks with and without the verbs. This site will claim no gain before that measurement.
Decided on 2 October 2026 on the author's delegation, from Softanza's own review of agent tooling. The judges above ran inside the library at commit 0e72e2e2c.