agents

Apps agents can operate

waid app scan reads your app’s source and identifies action candidates. Review them, author scoped handlers, and publish named actions like purchase_order.create that agents can call.

Become a design partner How the relay works

waid app scan

From source candidates to callable actions

React app

Vite + Tailwind

waid app scan

finds action candidates

Reviewed actions

authored schemas + handlers

Agent

calls semantic actions

at runtime

What the agent connects to

Your tools are served by the app itself over MCP. An agent lists them, calls one, and gets a structured result back from a handler running in your code.

Discovery happens in the protocol, not in a file. The agent asks the running app what it exposes, so the catalogue can never drift from the code that serves it.

action files

The shape of an authored action

waid app scan writes candidate names and source hints for review. You then author the input schema, consent policy, and handler that make an action callable.

Review it, refine it, and commit it, the agent surface lives in version control with everything else.

Use waid app sync to submit the app and its authored action catalog to ICE Develop. Publish and install the candidate separately in ICE before expecting tenant access.

src/actions/purchase-order.ts

// src/actions/purchase-order.ts
// Authored by you after reviewing `waid app scan` candidates.
export const createPurchaseOrder = defineAction({
  name: 'purchase_order.create',
  input: z.object({
    vendor: z.string(),
    lines: z.array(z.object({ sku: z.string(), qty: z.number() })),
  }),
  async handler({ vendor, lines }) {
    // runs in your app's own JS context
    const po = await api.purchaseOrders.create({ vendor, lines })
    return { id: po.id, status: po.status }
  },
})

the payoff

How an agent uses your WAID apps

PECO is an agent. It does not run on WAID - it calls apps that do. It uses the actions your apps publish and the measures your systems expose.

A person → PECO

One agent, in front of everything.

PECO is a client, not a platform. It connects to whatever speaks MCP - and the apps your team built with WAID speak it without anyone writing an integration for them.

in the chat

spend by vendor last quarter

The model plans and narrates. Code computes.

The model’s entire authority is selecting from a known vocabulary. It cannot name a column that does not exist, cannot write a predicate the source never declared, and cannot produce a number. This is text-to-metrics, never text-to-SQL - so a figure the model invented is not unlikely, it is structurally impossible.

WAID is the half that makes this possible.

An agent is only as good as the surface it can reach. `waid app scan` identifies action candidates in app source for developers to review and implement; `waid service scan` reads a backend’s Java sources and emits both its tool candidates and its per-dataset dimensions and measures.

After review, waid app sync and waid service sync submit candidates to ICE Develop. Publication and tenant installation remain separate; sync does not activate access or trust.

why it holds up

Production safeguards

Semantic, not coordinate

Agents invoke named actions with structured input, no brittle click-through-the-UI automation.

Reviewable in source

Scan candidates land in waid/app/generated/candidates.json. You review the source hints and author schemas and handlers before publishing callable actions.

Runs in your app

Each handler executes in your app’s own JS context and returns a structured result, your logic, your data.

Make your app the best tool your agents have.

We’re looking for design partners building agent-driven products.

Become a design partner