Turning Signal Forms into AI Agent Tools

What you actually get#

This is the most demo-friendly slice of WebMCP in Angular: instead of hand-writing a tool with a JSON schema and an execute callback, you let an existing Signal Form become the tool. Add provideExperimentalWebMcpForms() from @angular/forms/signals to your providers, pass an experimentalWebMcpTool option to form(), and Angular wires the rest.

The neat part is what the form already carries. Angular infers the tool's JSON schema from the form model's initial values, and it hooks the form's validation and submission into the call. So when an agent fills the tool, the validators you already wrote run; the agent sees the field errors and can correct itself, instead of pushing a half-valid payload at your submit handler. The same required rules that protect a human typing into the form now protect the agent calling it.

I read that as the form becoming a contract the agent has to satisfy, not a surface it pokes at. You write the form once, for people, and the agent gets the validated version for free.

// provideExperimentalWebMcpForms() must be in your providers
readonly model = signal({ firstName: '', lastName: '' });

readonly userForm = form(this.model,
  (f) => {
    required(f.firstName, { message: 'First name is mandatory.' });
    required(f.lastName, { message: 'Last name is mandatory.' });
  },
  {
    experimentalWebMcpTool: { name: 'registerUser', description: 'Registers a new user.' },
    submission: { action: async (formValue) => { /* ... */ } },
  },
);

What the schema inference needs#

The convenience has a price, and it is in the model. Angular reads the shape of the tool's schema from the model's initial values, so the values have to be concrete enough to read a type from. There is no separate schema you can correct by hand; the model is the schema.

Three constraints follow from that. First, every field needs a concrete initial value ('', 0, false), never null or undefined, because a type cannot be inferred from null. Second, arrays need at least one element so the item shape is known. Third, async validators do not run during agent submission, so anything you only enforce asynchronously will not gate the agent.

Read the table as the cost of skipping a hand-written schema. If a field cannot give a clean initial value, that is the field you have to think about before exposing the form.

Where this earns its place, and where I would wait#

I would reach for this on internal and admin forms that an agent drives: a back-office record an operator could fill by hand, or a batch action behind a flag, where the form already has good validation and the blast radius is small. There it is genuinely useful, and the validation gating the call is the feature, not a footnote.

I would wait on user-facing and regulated submissions. The forms half is settled now: Signal Forms are stable as of Angular 22. The agent half is not. WebMCP is experimental, a W3C Community Group draft, and the docs warn the APIs can change outside major versions. The deeper reason is that Angular does not validate that an agent's inputs match the inferred schema; you still validate inside submission for anything that matters. So it is one experimental layer now, not two: I would adopt Signal Forms on their own before trusting the agent layer on top in a revenue flow.