Imagine you hired an assistant who, every single time you asked them to file an expense report, sat down and re-invented the entire expense-filing process from scratch — reading the manual, testing which buttons work, and writing themselves fresh instructions. That's roughly how many production LLM agents behave today: every request triggers a fresh burst of "think, plan, generate code, try it, fix it." It works, but it's slow, expensive, and unreliable.

This paper proposes a smarter arrangement: let the agent make its own tools ahead of time, then just use them at runtime.

The approach works in two phases:

• Offline (the workshop phase): A "tool-maker" agent explores the live environment — poking at real APIs, watching what data comes back, and noticing which steps keep repeating in standard operating procedures (SOPs). When it spots a repeated pattern, it writes a proper function for it, tests that function against labeled examples, and fixes bugs until it passes. The result is a versioned, validated tool — code that reliably does one thing well.
• Online (the runtime phase): When a real user request arrives, the agent doesn't regenerate code. It picks the pre-built tool off the shelf and calls it. This shaves latency dramatically and eliminates a whole class of "the model wrote slightly wrong code today" failures.

The clever bit is that the tool-maker grounds itself in the actual production environment rather than guessing from documentation. It sees the real schemas, real values, real edge cases. That's the difference between a tool built from a textbook and one built by someone who's actually done the job.

There's also a self-evolution angle: as new failure modes appear, the system can generate new tools or repair existing ones, rather than being frozen forever at deployment time. This addresses a common gripe with agent systems — they either get locked in at training time (brittle) or improvise at runtime (slow and inconsistent). Tool-making sits between those extremes.

For anyone building customer-facing LLM agents, the tradeoff is compelling: you spend compute upfront to bake in reliability, and you get back predictable low-latency responses. It also means your logs become far more auditable — every action maps to a named, versioned tool rather than a fresh blob of generated code.