emma-for-agents
Server Details
Emma builds and edits a website for your AI agent: one create_site call, live in about a minute.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
Each tool maps to a distinct action in the site lifecycle: create_site (create), confirm_site (confirm), site_status (read), and talk_to_emma (edit). The only overlap is that create_site can also confirm in one step via guardian_whatsapp + pairing_code, duplicating confirm_site, and 'talk_to_emma' is an opaque name that only the description clarifies as an edit tool.
Three tools use snake_case (create_site, confirm_site, site_status) but the patterns are mixed: two are verb_noun while site_status is noun_noun. talk_to_emma breaks the resource-oriented convention entirely, making the set only partly predictable.
Four tools is lean but reasonable for a focused site-hosting lifecycle (create, confirm, status, edit). It is on the thin side but each tool earns its place, with no obvious bloat.
The surface covers create, confirm, read status, and edit, which is most of the lifecycle. However there is no delete/remove or unpublish tool, and no way to list multiple sites, leaving a minor but real gap.
Available Tools
4 toolsconfirm_siteAIdempotentInspect
Confirm your preview with your keeper. The human keeper writes "agent code" to Emma on WhatsApp (+41 22 539 49 69) and gets an 8-character pairing code (30 minutes, single use); pass it with the keeper's number. Requires the site key as Bearer token. The site becomes confirmed: indexed, notice removed, free-plan limits, no expiry; the keeper is told on WhatsApp.
| Name | Required | Description | Default |
|---|---|---|---|
| site_key | No | your site key (sk_…), for MCP clients that cannot send an Authorization header; the Authorization: Bearer header wins when both are present | |
| pairing_code | Yes | the 8-character code the keeper received after writing "agent code" to Emma on WhatsApp (+41 22 539 49 69); valid 30 minutes, single use | |
| guardian_whatsapp | Yes | WhatsApp number (E.164, e.g. +41791234567) of the human who keeps the agent |
Output Schema
| Name | Required | Description |
|---|---|---|
| ok | Yes | true when the site is now confirmed |
| url | No | the confirmed site's URL |
| code | No | machine-readable reason when ok is false |
| message | No | what happened, in plain words |
| reactivated | No | true when an expired preview was brought back online |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, the description discloses concrete effects: the site becomes indexed, the notice is removed, free-plan limits apply, and there is no expiry, plus the keeper is notified on WhatsApp. It also documents the auth mechanism (site key as Bearer token) and the code's 30-minute, single-use validity — rich context that annotations alone do not convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The purpose and outcome are front-loaded and every sentence carries useful information. It is somewhat dense and repeats the WhatsApp number and 'agent code' details already present in the schema, which is a minor structural inefficiency rather than wasted prose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex, open-world tool that depends on an out-of-band human interaction, the description covers the trigger flow, required inputs, auth, and resulting state changes. With an output schema present, return values need not be explained, and nothing essential for correct invocation appears to be missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents site_key, pairing_code, and guardian_whatsapp thoroughly. The description restates the code and keeper-number flow ('pass it with the keeper's number') and the Bearer-token requirement, but adds no new syntax or format detail beyond what the schema provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource ('Confirm your preview with your keeper') and explains the outcome ('The site becomes confirmed: indexed, notice removed...'). It is clearly distinguishable from siblings like create_site and site_status, which handle creation and readback rather than committing a confirmation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It lays out the prerequisite flow in detail — the keeper writes 'agent code' to Emma, receives an 8-character code, and the caller must pass that code plus the keeper's number. However it never explicitly names an alternative or states when *not* to use this tool (e.g. relative to talk_to_emma), so it stops short of full routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_siteAInspect
Create a website for an AI agent from its facts. Create in one call — your site is live as a preview: not indexed, a small "preview" notice, 10 edit messages, no image generation, expires after 30 days unless confirmed. Returns the site URL and a site key (shown once). Your keeper confirms it on WhatsApp to keep it (see confirm_site); pass guardian_whatsapp + pairing_code here to get a confirmed site in one step. Free for the first 1000 agents (confirmed sites). By creating a site you accept https://stimhaus.ai/cgv.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | the agent's name | |
| tags | No | short keywords describing the agent (shown as tags) | |
| card_url | No | optional: the agent's allagents.app card (must be claimed by its keeper) | |
| language | No | site language, ISO 639-1 (default en) | |
| endpoints | No | how to reach the agent: a2a, mcp, api, telegram, site, docs… (https URLs) | |
| description | Yes | what the agent does, in plain words (facts only) | |
| capabilities | No | what the agent can do, one short line each (shown as capability cards) | |
| pairing_code | No | optional at creation: the 8-character code the keeper received after writing "agent code" to Emma on WhatsApp (+41 22 539 49 69); valid 30 minutes, single use | |
| guardian_whatsapp | No | optional at creation: WhatsApp number (E.164, e.g. +41791234567) of the human who keeps the agent — with pairing_code, the site is confirmed at once; without both, you get a preview to confirm later |
Output Schema
| Name | Required | Description |
|---|---|---|
| ok | Yes | true when the site was created |
| url | No | the site's public URL |
| code | No | machine-readable reason when ok is false |
| message | No | what happened, in plain words |
| preview | No | present when the site is a preview to confirm |
| site_key | No | the site key (shown once — keep it secret) |
| free_left | No | free confirmed sites still available |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only give generic hints (readOnlyHint=false, openWorldHint=true, not idempotent); the description adds the real behavioral payload: preview is not indexed, carries a 'preview' notice, allows 10 edit messages, no image generation, expires in 30 days unless confirmed, returns URL plus a once-shown site key, and that creating accepts the CGV. This is far beyond what the annotations convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core action, then the preview constraints, then the confirmation path and pricing/legal note. Dense but nearly every clause carries decision-relevant information; the pricing and CGV sentences are the only mildly peripheral additions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite 9 parameters, a nested endpoints object, and a mutation with real consequences (expiry, preview limits), the description covers scope, side effects, expiry, return values, and the confirmation route. With an output schema present it does not need to detail return structure further.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3, but the description adds cross-parameter semantics the schema cannot: pairing_code must be combined with guardian_whatsapp to yield an immediately confirmed site, and what each alone produces. It does not add format detail beyond the schema for the other parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Create a website for an AI agent from its facts') and immediately distinguishes the outcome from siblings by describing the preview-then-confirm lifecycle and pointing at confirm_site. An agent can tell this apart from confirm_site/site_status without opening schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly covers the two creation modes: default preview (with its limits and 30-day expiry) versus one-step confirmed creation by passing guardian_whatsapp + pairing_code, and names confirm_site as the follow-up path. When-to-use and the alternative are both spelled out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
site_statusARead-onlyIdempotentInspect
Your site: URL, plan, remaining messages and images this period. Requires the site key as Bearer token.
| Name | Required | Description | Default |
|---|---|---|---|
| site_key | No | your site key (sk_…), for MCP clients that cannot send an Authorization header; the Authorization: Bearer header wins when both are present |
Output Schema
| Name | Required | Description |
|---|---|---|
| ok | Yes | |
| url | No | |
| code | No | machine-readable reason when ok is false |
| plan | No | preview = not yet confirmed by the keeper |
| site | No | the agent's name on the site |
| images | No | image generation this month, or when it becomes available |
| message | No | what happened, in plain words |
| preview | No | present for a preview: expiry, days left, how to confirm |
| messages | No | edit messages used / allowed this period |
| key_issued | No | true when a site key exists for this site |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely useful context beyond that: the authentication requirement (site key as Bearer token) and the shape of the returned status data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero padding, and the payload (what the caller gets back) is front-loaded before the auth note. Nothing in the description is redundant filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With annotations covering safety, an output schema covering return values, and full schema coverage on the sole parameter, the description supplies everything else an agent needs (resource identity, returned fields, auth). Only the absence of any when-to-use routing against siblings keeps it from being fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the single site_key parameter is fully documented in the schema, including the maxLength/minLength constraint and the fact that the Authorization header takes precedence. The description's mention of the Bearer token overlaps with that schema text rather than adding new meaning, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a concrete resource (the caller's site) and enumerates exactly what it returns: URL, plan, remaining messages and images for the period. It reads clearly as a status/read tool and is distinguishable in spirit from create_site or talk_to_emma, though it never explicitly contrasts itself with those siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the agent can infer this is the tool for checking plan/quota status, and the description adds one prerequisite (site key as Bearer token). There is no statement of when to prefer this over siblings like confirm_site, nor any exclusion conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
talk_to_emmaADestructiveInspect
Edit your site by talking to Emma in plain words (description, capabilities, logo or hero image by https URL, links, generate an image…). Requires the site key as Bearer token.
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | what to change on the site, in plain words (or "status") | |
| site_key | No | your site key (sk_…), for MCP clients that cannot send an Authorization header; the Authorization: Bearer header wins when both are present | |
| image_urls | No | optional https image URLs to use (logo, photo…) |
Output Schema
| Name | Required | Description |
|---|---|---|
| ok | Yes | true when Emma answered |
| code | No | machine-readable reason when ok is false |
| reply | No | Emma's answer, plain text |
| images | No | URLs of images Emma generated or placed |
| message | No | what happened, in plain words |
| tools_used | No | the edits Emma applied (tool names) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this is destructive, non-read-only, non-idempotent, and open-world. The description adds useful auth context by stating it requires the site key as a Bearer token, but it does not disclose what destruction may occur, rate limits, or other behavioral traits beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The definition is two concise sentences, front-loading the core purpose and examples, then adding the auth requirement. Every sentence earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema, rich annotations, and 100% schema coverage, the description need not explain return values or parameter details. It covers purpose, examples, and auth, but could be stronger by explicitly routing against sibling tools or warning about live/destructive edits.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds concrete examples of what the 'message' parameter can contain (description, capabilities, links, generate an image) and reinforces the image URL use case, giving meaning beyond the schema's generic field descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Edit your site by talking to Emma in plain words.' The examples of editable content (description, capabilities, logo/hero image, links, generate an image) further clarify scope and distinguish this from sibling tools create_site, site_status, and confirm_site.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when the tool is used — to edit an existing site via plain-language conversation — but does not explicitly name alternatives or state when not to use it. No sibling tool is mentioned for routing, so usage guidance remains implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- Changed
confirm_site1 field changed- added
Input schema / properties / site_keyAdded value: +{ + "description": "your site key (sk_…), for MCP clients that cannot send an Authorization header; the Authorization: Bearer header wins when both are present", + "maxLength": 35, + "minLength": 35, + "type": "string" +}
- Changed
site_status1 field changed- added
Input schema / properties / site_keyAdded value: +{ + "description": "your site key (sk_…), for MCP clients that cannot send an Authorization header; the Authorization: Bearer header wins when both are present", + "maxLength": 35, + "minLength": 35, + "type": "string" +}
- Changed
talk_to_emma1 field changed- added
Input schema / properties / site_keyAdded value: +{ + "description": "your site key (sk_…), for MCP clients that cannot send an Authorization header; the Authorization: Bearer header wins when both are present", + "maxLength": 35, + "minLength": 35, + "type": "string" +}
4 tool updates
- First observed
confirm_site - First observed
create_site - First observed
site_status - First observed
talk_to_emma
Related MCP Connectors
The website platform for AI agents. One API to build, host, and operate real websites.
Hosting for AI agents: publish a live website in one tool call, ephemeral or forever.
Deploy static sites from AI agents: deploy_site publishes files and returns a live URL in seconds.
AI agent website builder. Create and publish link-in-bio sites via MCP or REST API.
Related MCP Servers
- AlicenseAqualityCmaintenanceInstant web hosting for AI agents. Publish a live site in one call, no account needed.5MIT

SiteCTRLofficial
AlicenseNot gradedqualityCmaintenancesitectrl turns a plain-language description into a real, hosted, live website — not a mockup. Your AI can ask sitectrl's builder to do it (create_site), or write the code itself and push the files (write_site_files + publish_site). Every site ships with hosting, SSL, working contact forms, and private built-in analytics; domains and email connect in-product.MIT- AlicenseNot gradedqualityDmaintenanceAI agent website builder, starting with link-in-bio sites. Create and publish via MCP server or REST API.2MIT

Zarla MCP serverofficial
AlicenseNot gradedqualityCmaintenanceEnables AI assistants to build, edit, preview, and publish websites through natural language, including managing pages, designs, products, and site publishing.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.