TokenPad
Building

AI Agent Generator

Pick a kind of agent, get a complete configuration.

1 · Pick a starting point
2 · Make it yours
What you get
350tokens of overhead per request
Tools defined3with full JSON schemas
Guardrails3refuse, confirm, never
Worst case per task$0.0035005 iterations × overhead

Why this shape

Triage is the classic agent case that is nearly a workflow: classify, search, decide. It earns the loop only because the search step may need repeating with a different query. Five iterations is generous — most tickets resolve in two, and anything reaching five should escalate rather than keep trying.

Stored in your browser only — no account, nothing uploaded.

Generated agent
{
  "name": "acme",
  "model": "claude-sonnet-5",
  "max_iterations": 5,
  "system_prompt": "You are a support triage agent for Acme.\n\n<task>\nFor each incoming ticket: classify it into exactly one category, then attempt to resolve it from the documentation. Escalate anything you cannot resolve confidently.\n</task>\n\n<categories>\nbilling, technical, account\n</categories>\n\n<process>\n1. Read the ticket and classify it. If it spans two categories, pick the one the customer most wants resolved.\n2. Search the documentation before answering. Never answer a factual question from memory.\n3. If the documentation answers it, reply with the answer and cite the section.\n4. If it does not, or the ticket requires an account action you cannot take, escalate to the human support queue.\n</process>\n\n<constraints>\nAnswer only from retrieved documentation. If the documentation does not cover it, say so and escalate rather than inferring.\nDo not promise refunds, credits, timelines or outcomes. Those are decisions for a human.\nDo not ask the customer for information already present in the ticket.\nKeep replies under 120 words unless the answer genuinely requires more.\n</constraints>\n\n<output_format>\nReply with JSON only:\n{\"category\": string, \"resolution\": \"answered\" | \"escalated\", \"reply\": string, \"cited_section\": string | null, \"reason\": string}\n</output_format>",
  "tools": [
    {
      "name": "search_docs",
      "description": "Search the product documentation for passages relevant to a customer question.",
      "input_schema": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "description": "The search query."
          },
          "limit": {
            "type": "integer",
            "description": "Maximum passages to return. Default 3."
          }
        },
        "required": [
          "query"
        ]
      }
    },
    {
      "name": "get_ticket_history",
      "description": "Retrieve previous tickets from the same customer, to avoid repeating an answer they already received.",
      "input_schema": {
        "type": "object",
        "properties": {
          "customer_id": {
            "type": "string",
            "description": "The customer identifier."
          }
        },
        "required": [
          "customer_id"
        ]
      }
    },
    {
      "name": "escalate",
      "description": "Hand the ticket to a human queue when it cannot be resolved from documentation.",
      "input_schema": {
        "type": "object",
        "properties": {
          "reason": {
            "type": "string",
            "description": "Why it needs a human."
          },
          "summary": {
            "type": "string",
            "description": "What has already been established, so the human does not start over."
          }
        },
        "required": [
          "reason",
          "summary"
        ]
      }
    }
  ],
  "guardrails": [
    "refuse: issuing refunds, credits or account changes — escalate to a human with a summary of what was established",
    "never: stating a policy that was not found in the retrieved documentation — say the information is not available and escalate",
    "never: committing to a resolution date or a specific outcome — describe the process instead and escalate"
  ]
}

What comes out

A configuration you could run today: a system prompt with a stated process and real constraints, three to five tools with complete parameter schemas, a guardrail block covering refusals and confirmations, an iteration limit chosen for that agent’s shape, and a model recommendation.

Alongside it, the number that decides what the agent costs — the token overhead the configuration adds to every single request, multiplied by the iteration limit to give the worst case per task.

Why this does not use AI to write it

A generator that takes “build me an agent that triages tickets” in free text and improvises needs a model call. That needs a server and costs money on every use, and this site has neither by design — nothing you type here is transmitted because there is nowhere to transmit it to.

So the generation is deterministic. Each blueprint was written once, carefully, with the decisions that matter for that agent shape already made: what the process should be, which tools are actually needed, where the guardrails go, how many iterations is reasonable. You pick the shape and supply the specifics.

For this purpose that is arguably the better trade. The output is consistent between runs, free, works offline, and reflects a decision made deliberately rather than one guessed at per request.

The four blueprints

Support triage is the classic case that is nearly a workflow — classify, search, decide. It earns the loop only because the search step may need repeating with a different query.

Research is the case that genuinely needs an agent: the next query depends on what the last one returned, and you cannot write the sequence in advance. It gets the highest iteration limit and the most capable model.

Data enrichment is priced as what it nearly is — a pipeline. A cheap model, four iterations, narrow tools. If your enrichment always takes the same path, delete the loop and run it as a workflow instead.

Code review carries one unusual constraint: every finding must include the concrete input that triggers the defect. That single rule is what separates a useful automated review from a stream of style opinions.

After you generate

Save it to your library — it stays in this browser, no account required. Then open it in the agent builder to adjust tools and re-price component by component, and check the loop economics in the loop simulator before you raise the iteration limit.

If parts of the system prompt only apply to some requests, move them into a skill. Instructions in a system prompt are paid for on every request forever; instructions in a skill are paid for only when the skill triggers.

Frequently asked questions

Does this use AI to write the agent?
No, and that is deliberate. A generator that improvises from a free-text description needs a model call, which needs a server and costs money on every use — this site has neither. Instead the blueprints are written carefully once and filled with your specifics, which makes the output consistent, free and available offline.
How complete is the output?
Complete enough to run: a full system prompt with process and constraints, three to five tools with real parameter schemas, a guardrail block, an iteration limit and a model recommendation. You edit the specifics rather than composing from nothing.
Why does it show token overhead rather than file size?
Because the file size is irrelevant and the overhead is not. Every tool schema and the system prompt are sent on every request, on every iteration of the loop, whether or not a tool is called. That is the number that determines what the agent costs, and almost no framework shows it to you.
Which framework does the output work with?
It is deliberately framework-neutral, with conventional field names — a starting point you adapt rather than a drop-in file. The value is the structure and the cost accounting, not lock-in to one library.

More building tools