Zett Agent#
Agents that forge the tools they need.
Zett Agent is a small Python runtime for tool-calling agents. Its JIT harness lets a model write, reuse, and inspect its own tools in the middle of a run, so a long task stops paying for the same exploration twice.
Bring your own model and ordinary Python functions. Add skills, persistence, and delegation when you need them.
Your application
Python
from zett_agent.client import create_agent
from zett_agent.extensions.memory import InMemoryMessageAccumulator
from zett_agent.jit_harness import JITHarnessExtension
client = await create_agent(
model,
tools=[add],
extensions=[
InMemoryMessageAccumulator(),
JITHarnessExtension(),
],
)
await client.run("Build a tool that doubles 21, then use it.")
Written by the model, mid-run
Python
@tool(guidelines="Use to add an integer to itself.")
async def twice(value: int) -> int:
"""Add the same integer twice."""
return await harness.call_tool(
"add", left=value, right=value
)
Use a configured model inside an async function. Start with the complete, no-key example. Generated tools are trusted code, not a sandbox: read the JIT harness guide.
pip install zett-agent
uv add zett-agent
Let the model forge what it needs#
JIT here means building the tool environment when a task needs it, not a Python just-in-time compiler. The harness works through ordinary function calling, so it runs on Responses and Chat Completions alike.
Forge
create_tool registers a Python tool or a Markdown procedure the
model just wrote. A Python tool can span several files that import each
other.
Reuse and compose
Tools call each other through harness.call_tool. One outer call can
drive a loop of nested calls whose results never enter the context.
Inspect and unload
Source, profiles, and recent errors stay inspectable. Unload what the task no longer needs, and carry the toolbox to the next session in a snapshot.
Read the JIT harness guide for the control loop, what the model sees, and the trust boundary.
Everything you need. Only when you need it.#
Keep the first agent simple. Add capabilities without changing how you run it.
OpenAI, Anthropic, Google, DeepSeek, or Ollama. Use the same client, tools, and event callbacks with every built-in adapter.
Write a typed Python function. Its signature and docstring become the tool definition; the runtime validates and executes calls.
Show incremental text, reasoning when available, tool progress, and results. Connect your own terminal, UI, or service.
Keep skills in editable text files. Discover their instructions as needed, or search deferred tools on supported Responses endpoints.
Start here. Go further.#
Follow a tutorial, find a complete example, or look up an exact interface.
01 / Get started
Run your first agent without an API key. Then connect a provider, add tools, and stream a real answer.
02 / Find working code
Browse complete examples for sessions, approvals, context compaction, delegation, and cancellation.
03 / Make it yours
Build an extension for your workflow. Learn how to add tools, instructions, and progress events.
04 / Look it up
Explore the API reference for signatures, defaults, configuration fields, and examples.
Already building an application? Start with Configure your agent for defaults and request overrides, Integrate an application for timeouts and concurrent conversations, and Test your agent for deterministic tests.
A simple loop, from question to answer#
The model can answer immediately or ask for tools. Zett Agent runs those tools, returns their results, and calls the model again until it answers.
Your message
Model
Tools, if needed
Model
Answer
History, approvals, and context management extend that same loop. You choose what to enable; your application keeps control of its UI and resources. See how it works when you want the mental model.