AI Agent Config Builder
Design your agent: write the system prompt, define tools, configure memory and model settings. Simulate a multi-turn session in-browser. Export as JSON or YAML. No install. No API key needed.
Tools
Each tool needs a name (snake_case), a description the model reads to decide when to call it, and JSON Schema parameters.
Type a user turn. The simulator keyword-matches your tool descriptions and shows which tools would fire with mock arguments.
How to use
- Design tab: name your agent, pick a model, set temperature and memory strategy, write the system prompt, and add tool definitions. Click Load example to start from a working research agent.
- Simulate tab: type a user turn. The simulator shows which tools would fire and what the mock agent response looks like. Session is auto-saved to localStorage.
- Export tab: switch between JSON and YAML. Copy to clipboard or download. Use the JSON directly with the Anthropic or OpenAI tool API, or keep the YAML as a design doc in your repo.
Frequently asked questions
What is an AI agent config?
A structured document (JSON or YAML) defining the agent’s system prompt, tools (functions it can call), memory strategy, and model parameters. Frameworks like LangChain, LangGraph, Letta, and AutoGen all read variants of this format.
What is the difference between an agent and a simple LLM call?
A simple LLM call is one turn with no memory and no actions. An agent adds tools, memory across turns, and a loop that keeps acting until the task is done. The config defines all three.
How do I define tools for an AI agent?
Each tool needs a name (snake_case), a description the model reads to decide when to call it, and a parameters object in JSON Schema format. The description is the most important field — a vague description causes wrong or missed tool calls.
What is agent memory and how do I configure it?
Memory controls what history the agent sees each turn. Conversation memory passes all prior messages (simplest). Summary memory compresses old history to save tokens. Entity memory extracts key facts into a separate block. Start with conversation memory and max_turns: 20.
What is the Anthropic Claude tool use format?
Claude receives tool definitions in a tools array, each with name, description, and input_schema. When Claude calls a tool it returns a tool_use block; you send back a tool_result message. This builder generates configs compatible with this format.
What temperature should I use for an agent?
For tool-calling agents: 0.0–0.3. Lower temperature means more consistent tool selection. For creative or brainstorming agents: 0.7–1.0. Start at 0.1 and tune upward only if the agent feels too rigid.
How does the in-browser session simulator work?
The simulator scans each user message for keywords matching your tool descriptions. If a tool is likely to fire, it shows a tool_call block with plausible mock arguments, then appends a mock agent response. Session state is stored in localStorage and survives page refresh.
Can I use the exported config with LangChain or LangGraph?
LangChain and LangGraph define tools as Python function signatures — the JSON won’t import directly but is a useful design reference. The JSON maps closely to the Anthropic Messages API tools array, so it works directly there.
What is max_tokens and how does it affect cost?
Output tokens cost 3–5× more than input tokens. Set max_tokens to the largest response you ever need. 1024–4096 is common for tool-calling agents. Reducing it for simple extraction tasks can meaningfully cut API spend.
Why design agent configs in the browser?
Zero install, no API key needed for design, and your system prompts and tool definitions never leave your browser. The exported JSON or YAML is a portable artifact you can commit to your repo or load into any agent framework.
Worked examples
Research agent
Two tools: search and summarize. Conversation memory, temperature 0.1.
model: claude-sonnet-4-6 temperature: 0.1 memory: conversation / max_turns: 20 tools: - search_web(query, max_results) - summarize_document(url, focus) system: "Research assistant. Cite sources. Be concise."
Code review agent
Three tools: read, analyze, comment. Stateless — each PR review is independent.
model: claude-opus-4-8
temperature: 0.0
memory: none
tools:
- read_file(path)
- analyze_code(code, language)
- post_review_comment(
file, line, body, severity)
system: "Senior engineer.."
Support agent
Two tools: lookup and update ticket. Memory capped at 10 turns.
model: claude-sonnet-4-6
temperature: 0.2
memory: conversation / max_turns: 10
tools:
- lookup_ticket(ticket_id)
- update_ticket(ticket_id,
status, note)
system: "Friendly support agent.."
About agent config design
An AI agent is a language model connected to tools and a loop. The loop sends the model a message, lets it call tools, sends the tool results back, and repeats until the model produces a final answer. The config is the document that specifies every parameter of this system before you write a line of framework code.
The most important field in any agent config is the system prompt. It sets the agent’s persona, constraints (never call a tool without confirmation, always cite sources), and explicit guidance on when to use each tool versus when to answer directly. A 500-word system prompt is not unusual for a production agent. The simulator on this page lets you iterate on it without burning real API tokens.
Tool definitions are the second critical element. Each tool has a name (snake_case), a description, and a parameter schema. The description is read by the model at inference time to decide whether to call the tool. A description like “Get information” is too vague. A description like “Search the web for recent news and facts. Call this when the user asks about current events or anything that may have changed recently.” gives the model clear decision criteria.
Memory configuration controls how much conversation history the agent carries. Full conversation memory is simplest and most accurate but uses more tokens per turn. Summary memory compresses older exchanges, saving tokens at the cost of some fidelity. Entity memory extracts structured facts (names, dates, decisions) into a separate block, which is efficient for long-running assistants. The right choice depends on average session length and token budget.
Temperature is often misunderstood in agent contexts. Temperature 0 or 0.1 makes the model nearly deterministic in its tool selection and argument generation — critical for agents that call APIs with real-world side effects (sending emails, writing to databases). Higher temperatures suit creative agents where variety is the point. Setting temperature too high on a tool-calling agent causes hallucinated arguments and missed tool calls.
All config data in this tool is stored in your browser’s localStorage. No system prompt, tool definition, or session transcript is ever transmitted to any external server. Open your browser’s DevTools → Network tab and watch zero requests fire when you design or simulate. This makes it safe to prototype configs for sensitive production systems without worrying about prompt leakage.