apprun.icuAI tools

Agents & product · planner

Turn a product idea into an AI agent spec

Describe a product idea in plain words and get the agent's tasks, tool schemas in OpenAI, Anthropic and MCP shapes, acceptance tests, eval prompts, and a plain answer to whether you need an agent. Rules and templates, not a model. Nothing is uploaded.

Private runs in your browserNo model call rules and templatesExports Markdown, JSON, JSONL

Describe the idea

This tool runs in this tab. It does not upload or store what you type; the only thing kept is a file you choose to download.

The idea

0 of 20,000 characters
Known names are detected, for example Gmail, Outlook, Slack, Jira, GitHub, Notion, Google Calendar, Salesforce, Zendesk, Stripe, Shopify, QuickBooks and Airtable.

Rules for the agent

Autonomy
Risky capabilities: tick what the agent may do

Under Acts alone, a ticked box lets that kind of call run without approval and adds a server-side limit note. Unticked, the call keeps its approval step. Touching personal data adds a risk row only.

Examples: , ,

How to use Idea to Agent Spec

  1. Describe the idea. Use one to six sentences. Add who uses it and the systems it must touch, if you know them.
  2. Choose the autonomy and the capabilities. Under Acts alone, a capability you tick can run without approval, with a server-side limit note. Everything else keeps its approval step.
  3. Read the workflow verdict first. If the score is low, a fixed workflow may do the job before you build an agent at all.
  4. Edit, then export. Remove the rows you do not want, change the wording, and download the Markdown spec, the JSON bundle or the eval prompts as JSONL.

What the spec contains

The output fits one screen in a two-by-two grid: tasks, tool schemas, acceptance tests and eval prompts. Risks and the workflow verdict sit below it. Each block has its own copy button and count. Any row can be removed or restored, and the exports include only the rows you keep.

Tasks come from the archetype the idea matches. Each task has a trigger, inputs, an output, a recommended starting autonomy level and a human checkpoint. The acceptance tests are Given, When, Then statements. Given sets an initial context, When names the event, and Then states the expected outcome. Every task gets a happy path, an edge case and a guardrail, numbered AT-01 onward.

Eval prompts cover seven categories: happy path, ambiguous request, missing information, prompt injection, tool error, over-permission request and long context. Each prompt has an input, the expected behaviour, something the agent must not do, and a grader hint: schema-valid, exact match or rubric. Anthropic advises that each eval prompt be paired with a verifiable response or outcome, and that eval sets mirror the real task distribution. Its evaluation guide recommends automated grading where possible.

The same idea, the same settings and the same seed give identical output. The seed changes only example_arguments, the sample values shown beside each tool. Schemas, names and tasks stay the same. For sizing a tool description or a schema against a context window, the LLM token counter gives a quick estimate.

How the archetype and the matched words work

The text is lower-cased, reduced to stems, and checked against keyword lists for thirteen archetypes. The fourteenth entry is a general task agent, used when no keyword matches. A keyword adds its weight to the score. A word that appears in two forms, such as reply and replies, counts once at its highest weight. The archetype with the highest score wins, and ties go to the one listed first. If no keyword matches, the page uses the general task agent.

StepWhat the page does
MatchEach keyword or phrase is found as whole stems. Phrases such as "pull request" must appear in that order.
PickThe highest score is the closest archetype. Its matched words are listed so you can judge the match.
Second matchThe runner-up is shown with its score. It is marked a close call when it reaches 70 per cent of the top score. Its tools are not generated.
ObjectThe first object noun from that archetype's list that the text names fills the placeholders, such as "triage each new ticket". The default is the first noun in the list.
Action wordsVerbs such as send, refund, delete or run are listed. If the text uses one and its capability box is unticked, a hint asks you to decide.

For example, "Triage support tickets and draft replies" matches support triage on the words ticket, triage and reply. Keyword matching does not read negation: "do not send email" still matches the word send. That is why the matched words are shown.

Named systems are found by whole-word match. Gmail, Outlook, Slack, Jira, GitHub, Google Calendar, Zendesk, Stripe and about fifteen others are recognised. A tool whose family matches a named system takes that system's name as a prefix, so the search tool becomes zendesk_search_tickets. A system with no matching tool is listed, but it gets no tool.

Approval, limits and the four tool formats

Every tool has an effect: read, draft, write, send, spend or run code. Read and draft tools never need approval. For the others, the autonomy level and the capability boxes decide the approval step, as in this table.

EffectExamples in the tablesSuggest onlyHuman approvesActs alone, box tickedActs alone, box unticked
Read onlysearch, look up, readNoNoNoNo
Drafts onlydraft a reply or a messageNoNoNoNo
Changes recordsset a status, write rowsYesYesNo approval; server-side limit max_records (placeholder)Yes
Sends to otherssend a reply, create an inviteYesYesNo approval; server-side limit max_recipients (placeholder)Yes
Spends moneyrefund, place an orderYesYesNo approval; server-side limit max_amount (placeholder)Yes
Runs coderun tests, run a runbook stepYesYesNo approval; server-side limit max_run_seconds (placeholder)Yes

A limit is only a limit if the code that runs the tool enforces it. The page adds a placeholder so you can see where the cap belongs, and the limit is not a field the model fills. Set your own value and enforce it in your code.

Each tool is written in four shapes. The table shows the field names that matter here. The vendor documents define them.

PartOpenAI function callingAnthropic toolMCP tool
Namenamename, matching ^[a-zA-Z0-9_-]{1,128}$name, 1 to 128 characters (recommended by the spec)
Descriptiondescriptiondescriptiondescription
Schemaparametersinput_schemainputSchema, a JSON Schema object
Strictstrict: true, with additionalProperties false and every property requiredstrict: trueNot part of the shape this page writes

OpenAI's function-calling guide says that some JSON Schema features are not supported. Its structured-outputs page says the root must be an object and must not be anyOf. The checker covers a small subset of JSON Schema that this page chose. It is not a check of any vendor's rules: it tests an object root, typed properties, required lists every property, additionalProperties false, enum on strings, minimum and maximum on numbers, and maxItems on arrays. It also requires a description on every property. It does not check minLength, and it does not check maxLength against any vendor's list. OpenAI's structured-outputs page lists pattern and format as its string keywords, so confirm any string keyword against the API you use. Run each schema against the API you use before shipping.

Anthropic calls the tool description the most important factor in tool performance and suggests at least three or four sentences per tool. Each generated description says what the tool does, when to use it, when not to, and what it returns.

Do you need an agent at all?

OpenAI's practical guide says to validate three criteria before building an agent: complex decision-making, difficult-to-maintain rules, and heavy reliance on unstructured data. If the use case cannot meet them clearly, "a deterministic solution may suffice." Anthropic adds that agents suit open-ended problems where the number of steps is hard to predict, and that agent autonomy brings higher costs and the potential for compounding errors.

The verdict panel asks those three questions and a fourth about unpredictable steps, then counts the yes answers. Keyword detection makes the first guess, and you can flip any answer. Zero or one yes answers point to a fixed workflow. Two is a borderline case: prototype the fixed steps first. Three or four suggest an agent may be justified, with approvals, limits and tests in place. Three or four suggest an agent may be justified, provided approvals, limits and tests are in place. These bands are this page's rule of thumb. The sources give the criteria, not a number.

The advice behind the panel is Anthropic's: "we recommend finding the simplest solution possible, and only increasing complexity when needed". The same guide says this "might mean not building agentic systems at all." For the decision itself, read the guide on turning an idea into an agent spec. If the answer is a workflow, the tasks table still lists the steps to script.

Limits and what it cannot tell you

  • It is a template engine. Every task, tool, test and prompt is written for an archetype and filled with your nouns. It does not know your systems' real APIs, rate limits or permissions.
  • The archetype match is keyword based. Short ideas match weakly, and a sentence that says the opposite of what it means can still score. Read the matched words before you trust the archetype.
  • The verdict answers are guesses from keywords. You can change them, and the score changes with them. The bands are a rule of thumb, not a result.
  • The schemas pass this page's checker, not a vendor's. The checker covers a subset of JSON Schema, and each vendor accepts a different subset.
  • Acceptance tests and eval prompts are not measured results. A single passing run says little. In the τ-bench paper from June 2024, gpt-4o reached about 61 per cent pass^1 on retail tasks, and pass^8 stayed below 25 per cent. That result covers two domains with a simulated user and an older model. It shows why repeated trials matter. It is not a current benchmark.
  • Anthropic's December 2024 guide says much of its tooling has changed since then. Check the current documentation for the API you use.
  • Risk rows are prompts for thinking. The page does not score a risk with a number. OpenAI's guide rates tools as low, medium or high risk by read or write access, reversibility, permissions and financial impact.

For writing better tool descriptions in more depth, read the guide on writing tool schemas for LLM agents.

Privacy: what happens to your input

The idea, the audience and the systems fields are read by JavaScript in this tab. This tool does not send or store them: it makes no network request with that text and writes none of it to local storage, cookies or IndexedDB. Close the tab and the text is gone. The site around the tool is separate. Its shared widgets, a store widget, an offer popup and a service worker for saved pages, may keep their own settings in the browser, and none of them receive what you type here.

The share link holds only the autonomy level and the capability ticks, in a short settings string. It never contains the idea. Downloads are files your browser saves to your device.

Do not paste API keys, customer records or passwords into the idea. The spec is a plan, and a plan that goes into a shared document should not carry secrets.

Questions

Is my data uploaded?

No. This tool reads the idea in this tab with JavaScript. It makes no network request with the idea, the audience or the systems text, and it stores none of them. The share link carries only the autonomy level and the capability ticks, never the idea. The site around the tool has its own shared widgets, which are separate from this tool.

How accurate is this?

It is a rule-based scaffold, not a model. The archetype comes from keyword weights, so an unusual phrasing can land on the wrong one. Check the matched words, reword the idea if they are wrong, and treat every task, schema and test as a draft to review against your real systems.

Do I need an agent for this?

Often you do not. Anthropic recommends “finding the simplest solution possible, and only increasing complexity when needed”, and says this “might mean not building agentic systems at all”. The verdict panel asks four questions from the sources. This page’s rule of thumb: zero or one yes answers point to a fixed workflow; two is a borderline case to prototype first; three or four suggest an agent may be justified.

Should the agent get as many tools as possible?

No. Anthropic writes that “More tools don’t always lead to better outcomes”. This page generates four to six tools per archetype on purpose. Delete the ones the agent does not need before you export, and group related tools under a shared prefix.

Why does a sending or spending tool need approval?

OpenAI says “Actions that are sensitive, irreversible, or have high stakes should trigger human oversight until confidence in the agent's reliability grows.” This page applies its own rule to send, spend, record-change and code-run tools. Acts alone removes that gate only for a capability you ticked, and then adds a server-side limit note. The approval is enforced by the code that runs the tool, not by a field the model fills.

What does the strict flag do?

It asks the API to follow the schema reliably instead of on a best-effort basis. OpenAI says strict mode makes calls “reliably adhere to the function schema, instead of being best effort”, and requires additionalProperties false with every property listed as required. The generated schemas follow both rules. Anthropic’s guidance is to set strict: true on tool definitions.

Is the OpenAI Evals platform a good place to start?

Not for new work. OpenAI says it is deprecating the Evals platform: read-only for existing users from October 31, 2026, and scheduled to shut down on November 30, 2026. Its notice suggests trying Datasets instead. The eval prompts here are plain JSON Lines that any harness can read.

Are these eval prompts enough to trust an agent?

No. They are a starting set. Anthropic advises that more automated questions with slightly lower signal beat fewer hand-graded ones, so add real cases from your own traffic, grade them with code where you can, and measure repeated runs before you widen autonomy.