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.

UCL · the product from the paper

Say the name. Leave the book.

The AI asks. The computer does the job. UCL shows the AI a short list of names. The rulebook stays in the kitchen.

Same job, side by side

Whole book

A JSON schema, pasted in

Read the types
Still in the book
Then say read_file
The book was already copied in

Name list

Names only. No schema.

See three names
I need read_file
path: src/main.py
The book stays on the host

Rulebook

Both sides want the same file. The book side is reading a JSON schema. The name side already has three names.

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

Add more tools and the book gets taller. The name list adds a 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.