Forms for AI agents: why YeetForm has an MCP server

Forms aren't just for people to fill in anymore

More of your work happens through an AI agent now. You ask Claude Code to check something, you ask Cursor to scaffold a feature, you ask a support bot to gather details before it escalates a ticket. Increasingly, "gather structured information from someone" is a task an agent hands off, not something you build a UI for by hand every time.

That's the gap YeetForm's MCP server fills. It lets an agent create a form, read its responses, or generate a whole new form from a plain description, without you opening a browser tab.

It's a small shift in how you think about forms. A form used to be something a person built once, in advance, for other people to fill in later. Now it can be something an agent builds on the fly, mid-conversation, because the task in front of it needs structured input and a form is the fastest way to get it reliably.

What MCP actually is, in plain words

MCP (Model Context Protocol) is a standard way for an AI agent to call tools that live outside the chat window. Instead of the model guessing at an API by reading docs, it gets a list of tools with clear names and inputs, and it calls them directly. Claude Code, Cursor, and ChatGPT can all speak MCP.

For YeetForm, that means an agent doesn't need to know our REST endpoints or auth flow. It just needs to know it has a tool called create_form, and what to pass it.

Before MCP, giving an agent access to a product meant a custom integration, or hoping the model could improvise a correct HTTP request from documentation it half-remembers. MCP replaces the improvising with a fixed, typed list of actions the agent reads and calls with the right shape of input.

It also means the same server works across clients. The tool definitions don't change whether you're inside Claude Code, Cursor, or another MCP-aware agent. Set it up once per client, and every agent that connects gets the same six capabilities.

The six tools

YeetForm's MCP server, at /api/mcp, exposes six tools:

• list_forms: see the forms in your workspace
• get_form: pull the full schema for one form
• create_form: create a form from a schema you (or the agent) define
• list_responses: pull recent responses for a form
• get_response: pull one response in full
• generate_form_from_description: the AI generation path, exposed as a tool: describe the form in a sentence, get a built form back

That last one is the interesting bit. It means an agent doesn't need to construct a form schema by hand. It can say "build me an intake form for support tickets with a priority field" and let YeetForm's own AI generation handle the structure, the same generation that powers the product itself.

The other five tools cover the rest of a normal workflow. list_forms and get_form are read operations, useful when an agent needs to check what already exists before deciding to create something new, or when it needs the current schema before proposing an edit. list_responses and get_response do the same for the data coming back in, letting an agent summarize, filter, or act on submissions without a person exporting a CSV first. create_form is the manual path, for when the agent (or you, through the agent) already knows exactly what fields and logic the form should have and just needs it created.

Put together, the six tools cover the full lifecycle: describe or define a form, create it, and read back what people submitted, all from inside whatever agent you're already talking to.

Setting it up

If you're on Claude Code, adding the server is one command from your terminal:

claude mcp add yeetform https://yeetform.io/api/mcp

Full setup steps, including the equivalent for Cursor and other MCP-aware clients, are on the /mcp page. Once it's added, the agent has the six tools available in any conversation, scoped to your workspace via an API key.

Three things people actually do with this

Weekly NPS pull, from Claude Code. Instead of logging into the dashboard every Monday, you ask Claude Code to run list_responses against your NPS form, summarize the trend since last week, and flag any detractor comments worth reading. It's a two-line prompt instead of a spreadsheet ritual.

A support bot that opens an intake form. Your support agent, whatever it's built on, hits a case that needs structured detail it can't get from free text alone: order number, affected feature, screenshots. Instead of improvising a reply, it calls create_form (or generate_form_from_description) to spin up a short intake form on the spot and sends the link. The customer fills in exactly what's needed, once.

A Cursor task that scaffolds a signup form. You're building a landing page and need a working waitlist form fast. You ask Cursor to generate one via MCP, get back a real hosted form with a slug, and embed it with the JS SDK before you've finished the rest of the page.

Closing the loop with webhooks

Creating the form is half of it. The other half is knowing when someone fills it in. YeetForm supports signed webhooks (HMAC-SHA256, up to three delivery attempts) so your agent, or whatever's downstream of it, gets notified the moment a response lands. That's what turns "an agent made a form" into an actual workflow: agent creates the form, human fills it in, webhook fires, agent picks the thread back up.

Combine that with the MCP tools for reading responses and you've got a full loop that never needs a person to babysit the middle step.

A small shift, not a gimmick

None of this replaces a person deciding what a form should ask. It replaces the busywork between deciding and having a working form: opening a builder, placing fields, wiring logic, publishing, sharing a link. If an agent is already doing the surrounding work, whether that's triaging support tickets or building out a feature, it makes sense for it to handle that step too, and hand you back a link when it's done.

Where to go next

Read the developer docs for the REST API and webhook details, or the /mcp page for the exact tool schemas and setup steps for your client of choice.

Point an agent at it and see what it builds.