agents

Apps agents can operate

waid app generate-mcp reads your app’s source and drafts MCP tools for named actions like purchase_order.create. Review the diff, expose the tools you want, and agents can call them.

Request access How the relay works

waid app generate-mcp

From app source to callable tools

React app

Vite + Tailwind

waid app generate-mcp

drafts MCP tools

Exposed tools

reviewed in waid/mcp/curation.json

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 generate-mcp has your local coding agent draft the input schema and handler for each tool, then builds and verifies them. New tools start denied until you expose them.

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
// Drafted by `waid app generate-mcp`, reviewed by you.
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 generate-mcp` drafts MCP tools from app source for developers to review and expose; `waid service generate-mcp` does the same for a backend’s Java sources, alongside its curated 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 onboarding early-access teams building agent-driven products.

Request access