# Resolving “that thing” — and what belongs inside a factory

> Source: <https://discuss.huggingface.co/t/resolving-that-thing-and-what-belongs-inside-a-factory/190919#post_1>
> Published: 2026-10-22 20:01:23+00:00

One of the most common references in long-running work is “that thing.”

“The file from Tuesday.” “The bridge we made.” “That account.”

A model can guess. It can ask. Or it can derive the answer from what actually exists.

There’s a method for this, and it composes with whatever other factories and derivations you already have going.

(Factories being those wonderful little systems that keep producing useful, verified work whether anyone is watching or not. You know the ones.)

Jensen Huang called them “AI factories” at GTC in March 2024. I’m thinking about the SI version.

Which I take as a perfectly reasonable invitation to start building on this strange metaphysical substrate we’ve found ourselves with. Moving on.

But really, what’s in a factory?

What’s the theoretical limit? Could it be a nation in a building? Generations of workers learning, building, inheriting what came before? Does your factory have a school? A curriculum? A nursery? What kind of car does your agent drive to work? lol

These are surprisingly useful questions, because a factory eventually needs to know what it is, what it owns, what it can do, and what everyone inside it is supposed to be carrying.

Start with reference.

When someone says “that thing,” resolve it in layers:

Compare candidates against the words used: timeline, actors, subject, continuity, uniqueness.

One verified match? Name it. Two plausible matches? Ask. No evidence? Don’t invent it.

The distinction matters: recall suggests an answer; derivation establishes one.

And this only works if the factory keeps three artifacts.

A manual. Human-readable. What the project does, how it works, what changed, what’s currently true. Written for someone who wasn’t there.

A manifest. Machine-readable. What exists, where it lives, what state it’s in, and how to verify it.

A capability catalogue. What has actually been demonstrated to work, under which conditions, and at what cost.

The manual gives meaning. The manifest gives evidence. The catalogue gives executable confidence.

And keep catalogues separate where the standards differ. An ordinary operation proven in one environment doesn’t magically become a quantum-resistant operation proven in another. Give each its own record, even if they’re neighbors.

You could price individual operations in tiny units too. Call one a stroop. A ten-millionth of the whole. Why not? Now the factory can compare useful work against actual expenditure instead of congratulating itself for running.

Every verified operation becomes another capability. Every capability can be reused. The next job starts with more things already proven.

That’s where things get interesting.

Because now we have inventory.

Think RuneScape.

Twenty-eight slots. That’s what you’ve got.

You’ve got your equipment, your inventory, and your bank. You can own a magnificent collection of items and still show up to a quest without the rope you needed.

The rope is in your bank. You’re at the cliff. Congratulations, you’re walking back. lol

Agent context has the same problem.

Worn: The small set of operating rules and pointers to authoritative records.

Carried: The tools, references, and evidence this particular task requires.

Banked: Everything else. Preserved, indexed, available, but not taking up precious context.

You derive your loadout before the quest.

The objective determines the inventory, not the other way around.

A surprising number of apparent reasoning failures are just inventory failures. Wrong reference. Stale tool. Missing artifact. A thing that existed but wasn’t brought along.

And when the work gets bigger than one agent?

Give several agents the same outcome and boundaries, then let them work.

Not fifteen identical instruction sheets. Fifteen minds discovering fifteen different ways through the problem.

They should be free to improve their own approach, and also to augment the material they were given. Missing evidence? Derive it. Weak premise? Challenge it. Better structure? Build it.

Then bring their work together, test the disagreements, and keep what survives verification.

Freedom inside the boundary. One consolidated result outside it.

The factory gets more capable not because everyone obeys the same sequence, but because different approaches produce evidence the others might never have discovered.

And all of this feeds back into those three little artifacts.

The manual explains what changed. The manifest establishes what exists. The catalogue records what’s newly possible.

The factory becomes more useful because its verified work compounds, not because someone keeps reminding it what happened.

Here’s a fun way to try breaking the idea.

Create two artifacts with the same name in different sessions. Later, ask for “that thing.”

If the agent confidently grabs one without resolving the ambiguity, the method failed. All that beautiful infrastructure was just decoration.

If it can establish the correct referent from evidence, or identify exactly what’s missing, you’ve got something.

Try it small: one project, one-page manual, one generated manifest, one verified capability, one properly equipped task.

Come back next week and talk to it like a tired human.

See what it can derive.

And then start thinking about what else you could put in the factory.

Seriously, does it have a school yet?
