What is the name list?

The AI only needs the names of its tools. The computer that does the job keeps the rulebook. This is the UCL product from the Universal Conditional Logic preprint (arXiv:2601.00880).

Does the whole rulebook make the AI more correct or faster?

On one local 35B test, names passed 85.4% and the whole book passed 84.4%. The book used more text (4,307 tokens vs 2,374). It was not faster. The book averaged 32.4 seconds and names averaged 34.2.

How does the model decide?

It looks at what it was shown, picks a name, and says the arguments. With the name list that is three short names. With the whole book it reads types and descriptions first. The computer still checks the request before it runs the tool.

The name list · Anthony Mikinka

Three turns, side by side

Turn 1

Normal tools

The JSON schema is pasted again

UCL lean

One line per tool. No schema.

Host check waits

Normal 0
UCL 0

The bars count characters in this picture of the catalog, not the lab’s session tokens. The measured session is still 4,307 versus 2,374. Each turn below resends the catalog. Turn 3 adds grep, so the normal side gains another schema.

What Loom actually does

The model gets a short line. The host keeps the types and checks them before the tool runs.

1 · Prompt Lean mode writes one line into the system prompt. The JSON schema is not in that line.
```
- `read_file(path: string)`: Read a workspace-relative text file.
```

2 · Model It answers with a small call. It does not run the file read.

{"loom_tool_call": {"id": "c1", "name": "read_file", "arguments": {"path": "src/main.py"}}}

3 · Host Allowlist, then param_types, then the real function. This check never went to the model.
```
path: workspace_path
offset: non_negative_int
limit: non_negative_int
```
4 · Result The host sends back loom_tool_result. The model uses that, or asks again.

From Loom: format_tools_section with presentation lean, and ToolDispatcher checking param_types before the tool body. Full mode is the other path: it also appends Schema: {...}.

The book is this JSON

Same tool. One side is handed the schema. The other side is handed the name.

Pasted into the model

{
  "name": "read_file",
  "parameters": {
    "type": "object",
    "properties": {
      "path": { "type": "string", "description": "…" }
    },
    "required": ["path"]
  }
}

It still only answers

{
  "name": "read_file",
  "arguments": { "path": "src/main.py" }
}

Shown to the model

read_file — read a text file
list_dir — list a folder
grep — search contents

It answers the same way

{
  "name": "read_file",
  "arguments": { "path": "src/main.py" }
}

The schema stays on the host and checks that path is a string.

Later, side by side

Every new turn sends the catalog again. Full mode adds another schema. Lean mode adds another line.

Whole book, after more tools

Each new tool pastes another schema into the model. The pile is sent again on the next turn.

Name list, after more tools

The schemas stay in this box, on the host. The model only sees the lines above.

A picture of the idea, not a second measurement. The bars below are one catalog, one run. This is what happens to that catalog when the toolbox grows.

Less to read

Names used about half the text of the whole book. The score stayed level.

No list1,610
Names2,374
Lean2,829
Whole book4,307
Native tools4,150

Tokens the model read in one session. Names 85.4% correct. Whole book 84.4%. Native tools 66.7% under this score, mostly because the arguments had to match.

Not faster

Less text did not mean less waiting. The whole book was the fastest average.

Whole book32.4s
Names34.2s
Native tools35.0s
Lean35.8s
No list37.2s

A blinkChecking the request. Not the wait you feel.
~35sOne question to the model.
~4hAll 408 test questions in a row. Not a chat.

This is the product from Universal Conditional Logic. The paper’s own result was 29.8% less text on specifications. The bars above are a later test of tool names. Do not add those percentages together. The short essay has the same numbers in sentences.

Say the name. Leave the book.