MCP App Store
by KeenEthics
AgentBuild icon

AgentBuild MCP Server for ChatGPT

By AgentBuild, Inc

Overview

AgentBuild is an agent-first website builder. It gives the agent you already use the tools to design, build, and manage your website through chat, without requiring a separate website editor. Describe your business; it creates the site from curated sections and templates, adds your content, and deploys a preview for review. Nothing is published to your domain until you approve it. Connect a domain you own, and AgentBuild handles the site connection, DNS records, and email setup. After launch, ask your agent for changes whenever you need them. Hosting, structured data, core SEO, traffic and lead reporting, and rollbacks are included.

How to connect

  1. ChatGPT: Open the AgentBuild listing in the ChatGPT app directory and choose Connect. ChatGPT listing AgentBuild exposes 58 tools here.

Tools

account_get

ChatGPT
Fetch the human's account profile: email, plan, and saved contact fields (first_name, last_name, phone, city, country, etc.). Use this to inspect which profile fields are already saved — typically before calling account_update_contact so you only ask the human for fields that are still missing. Street address returns only as address_on_file. (Contact details are stored on the account profile for support and any future registrar features; AgentBuild does not register domains in-connector — the human buys a domain at any registrar and connects it with domain_add_custom.) Returns structured data in structuredContent.account.

account_update_contact

ChatGPT
Stores human-provided contact details on the account profile. This write is appropriate when the human asks to record or update those details; contact data is optional for launching a site, attaching a domain, and publishing. Any subset of fields is accepted and merged with existing values. A single call can batch the fields supplied by the human, reducing separate approval prompts for PII writes. Phone values use E.164 format-a +, country code, and digits-and country values use ISO 3166-1 alpha-2 codes. Server validation returns invalid_contact for invalid merged values. Returns the updated profile in structuredContent.account. Contact details remain private account data and are not published.

asset_delete

ChatGPT
Deletes an uploaded asset from the site's library by ID from asset_list, freeing its quota slot. It refuses with asset_in_use while a section still references the asset; remove those references with content_update, then retry. The underlying file is retained so previously published versions keep rendering.

asset_list

ChatGPT
List all uploaded assets (images, files) for a site with their URLs. Returns structured data in structuredContent.assets: { items, total, storage }.

asset_upload

ChatGPT
Stores an image or file in the site's asset library and returns its ID, URL, alt text, media type, and dimensions. Formats: JPEG, PNG, WebP, GIF, AVIF, SVG logos, PDF, MP4, WebM; 10 MB limit, server-side validation. Exactly one transfer field is accepted. A chat-attached file arrives host-filled in attachment; pass it through unchanged the same turn. content_base64 suits small in-band assets the agent already holds; media_panel lets the human pick or upload photos themselves. Local stdio clients may use an absolute file_path inside AGENTBUILD_UPLOAD_DIR; outside paths return PATH_OUTSIDE_SANDBOX. A successful upload returns id and url; placement is a separate site_settings_update or content change using the returned URL, alt text, width, and height. Logo-purpose assets can be auto-installed by site_build. A PNG named favicon.* becomes the favicon on the next deployment.

billing_status

ChatGPT
Reads the account's plan state: { plan, status, complimentary } plus capacity facts (live_sites, live_sites_included, draft_sites_remaining) for deciding whether another publish or draft site fits. status is the account's subscription state (trialing includes the platform trial; also active, past_due, ...); complimentary: true means full access with no subscription to manage. Read-only: no checkout or account changes. Returns structuredContent.billing.

content_create

ChatGPT
Creates one typed content item, such as a page or blog post, on the preview lane. section_types provides the accepted field shapes for page sections. A minimal page: { type: "page", slug: "home", data: { title: "Home", sections: [{ type: "hero", variant: "centered", content: { heading: "Welcome" } }] } }. A new page is reachable at its URL but is not automatically added to primary navigation; site_settings_update manages authored nav_items. Legal pages can use data.nav_placement: "footer" for fallback footer navigation, and data.noindex: true keeps a page (a thank-you or paid landing page) out of search engines and the sitemap. Blog posts require the blog feature enabled through feature_set. Public content reflects supplied business facts. Unknown factual material remains a clearly marked placeholder tracked through discovery_update. The live custom domain changes only after site_publish.

content_delete

ChatGPT
Delete a content item permanently.

content_get

ChatGPT
Get full details of a specific content item by ID. Use this to read a page's sections, a blog post's body, or any content item. More efficient than content_list when you already have the ID. Returns structured data in structuredContent.content: { id, type, slug, data, created_at, updated_at }.

content_list

ChatGPT
List content items for a site — summary mode by default. Each item carries id + type + slug + a small per-type summary (page → title + section_count + section_types[]; business-info → name + category; blog-post → title + excerpt; etc). Use this to find content IDs for updates without paying the cost of the full data blob (which can be 5-10 KB per page when sections are populated). Returns structured data in structuredContent.content: { items, total }. If you need the FULL data (e.g. to read a page's section content before update_and_deploy), pass verbose: true — that returns the same items with the complete data field populated. Or, if you already have the ID, use content_get instead — it's the targeted form and never returns more than the one item you asked for. Filter by type to scope the list (page, blog-post, menu-item, product, business-info, team-member, testimonial, faq).

content_update

ChatGPT
Updates an existing content item's data or slug by its ID from content_list or content_get. When data is supplied, it replaces the stored data object in full (never a partial merge). section edits one section in place by its section_id; insert splices ONE new section at a chosen position. Both are exclusive with data/slug, carry expected_revision, and beat a full data replacement (a re-sent array can silently alter untouched sections). A data replacement that drops stored sections lists the dropped ids in confirm_section_removals after the human's go-ahead. The preview refreshes only via site_deploy, after a completed batch of edits. Strings inside data become public-site copy in the business's voice, never conversational notes.

discovery_start

ChatGPT
Loads the saved business brief, DiscoveryChecklist, and highest-priority pending items at the beginning of a discovery session. With domain: "new", the response lists existing sites or supplies first-site guidance. After a new site is created with site_create, the site's slug loads its checklist. With an existing slug, the response resumes saved answers and identifies the next pending topics, avoiding repetition of completed discovery. theme_presets supplies current visual-direction choices. Saved discovery state is the source of truth for later discovery_update and site_build calls.

discovery_update

ChatGPT
Persists discovery answers as they arrive and returns updated next actions. One call per human message, with one item per topic that message resolved, preserves the adaptive discovery loop. Each accepted call writes a new brief revision. Values record what the human supplied, never invented facts. answered represents a real answer, skipped records an unavailable or declined item, and placeholder records scaffolded material. A placeholder needs a note of 10+ characters saying what was scaffolded and what is needed, or the server returns NOTE_REQUIRED_FOR_PLACEHOLDER. An answered business_name records the human's name in its note; an empty note returns NAME_REQUIRED_FOR_ANSWER. discovery_start restores this saved state in later sessions. Downgrades from answered to not_asked are ignored; placeholder represents an item that needs renewed attention.

dns_list

ChatGPT
List all DNS records for a site's custom domain. Use to inspect or debug DNS configuration. Returns structured data in structuredContent.dns: { records, total } (or { records: [], message } when no custom domain attached).

dns_preset

ChatGPT
Applies a preconfigured DNS setup. basic-website adds the minimal website records. microsoft-365-email adds Microsoft 365 MX, SPF, autodiscover, and DMARC records. google-workspace-email writes Google Workspace MX, SPF, and DMARC records and is suitable for a confirmed active Workspace subscription; without one, the records are live but nonfunctional and inbound mail can bounce. email_setup(mode="workspace", workspace_verified=true) provides the confirmation-gated Workspace path.

dns_set

ChatGPT
Creates one DNS record (it does not update or delete existing records). Existing records cannot be changed or removed through these tools yet; for a correction, use support_escalate. For common setups (Google Workspace, M365), use dns_preset instead.

domain_add_custom

ChatGPT
Attaches a domain the human already owns so the site can later be published there. An ACTIVE zone already on AgentBuild (the domain itself, or the parent of a subdomain such as blog.example.com) attaches without a nameserver change; domain_verify completes host setup before site_publish. A zone that exists but is still pending returns the nameservers to set plus delegation_domain (the parent, for a subdomain). A newly connected apex uses full nameserver takeover: Cloudflare becomes authoritative, the zone is created, public DNS is scanned, and detected MX, A, AAAA, CNAME, TXT, and SRV records are imported, with the count and any email provider reported. resource://agentbuild/byod-walkthrough covers record review, the registrar change, and propagation. domain_verify follows once the human confirms the change was saved. Keeping the existing DNS provider authoritative is not supported by this path; the preview URL stays available when DNS must remain unchanged.

domain_check

ChatGPT
Checks the public registry record (RDAP): is this name registered? The registrar confirms final availability and price at purchase (unregistered names can be premium-priced); connect via domain_add_custom. Returns structuredContent.domains: { domain, available (null = unknown, not taken; note explains), registrable, registrable_reason?, note?, tld }[].

domain_list

ChatGPT
List the domains the human has on AgentBuild: BYOD domains connected via domain_add_custom (parent zones and subdomains; legacy rows may show registrar 'namecom'). Use it when the human asks what domains they have, when checking whether a custom domain already exists before site_publish, or before coaching them to connect another. Each row carries domain, registrar ('namecom' or 'external'), status, registered_at (the connect date here, not the registrar's), expires_at, auto_renew, whois_privacy, and attached_to_site (the sites currently using the domain at apex or any subdomain; empty array when no site is attached). auto_renew / whois_privacy are null on every row — AgentBuild holds no live registrar relationship, so they are unknown here, not off. Renewal and privacy questions go to the registrar the human bought the name from. To check if a name is available, use domain_check. Returns an empty list (not an error) when the human owns no domains yet; next_actions guide toward domain_check / domain_add_custom.

domain_verify

ChatGPT
Checks whether the attached domain's nameservers point to AgentBuild and activates the custom-domain connection. The human's confirmation that the registrar change was saved precedes verification. DNS propagation usually takes 5-30 minutes and can take several hours. A not propagated yet result reflects that delay and supports a later verification attempt. After two unsuccessful checks following confirmed registrar changes, support_escalate can include the domain and registrar for direct assistance.

email_catchall

ChatGPT
Sets the destination for email sent to unmatched addresses on the custom domain. Initial setup is email_setup(mode="forwarding"), which also configures notifications. email_catchall supports later changes to the existing catch-all destination.

email_forward

ChatGPT
Adds one address-specific forwarding rule on the custom domain, such as hello@mybakery.com to owner@gmail.com. Initial setup is email_setup(mode="forwarding"), which configures catch-all delivery and notifications. email_forward supports additional per-address routes after that setup.

email_setup

ChatGPT
Configures email for an attached custom domain in one of three modes. forwarding routes received domain mail to forward_to (refused with existing_mail_detected when the domain already has live MX). workspace configures MX, SPF, and DMARC for an existing Google Workspace mailbox; already-live Google MX records the route only, changing no DNS. external records that the domain's email already works elsewhere and changes no DNS — it only sets notify_to, where contact-form submissions are delivered. Workspace mode requires workspace_verified: true only after the human confirms the mailbox is active (premature DNS makes inbound mail bounce), plus their verbatim approval in human_authorization (hard-to-undo DNS). Forwarding and external are reversible and skip that gate. The chosen destination delivers contact-form submissions and appears as site.email.notify_to in site_status. An attached custom domain is a prerequisite; domain_add_custom handles a domain the human already owns.

email_verify

ChatGPT
Checks email deliverability by verifying SPF, DKIM, and DMARC records. For Google Workspace, a score of at least 2/3 also clears site_status.email.workspace_pending after Workspace setup has been completed.

feature_set

ChatGPT
Records a site capability flag: blog, forms, products, bookings, or members. blog is the implemented workflow: enable it, create blog-post items with content_create, add a blog-list section, and refresh the preview with site_deploy; posts render at /blog/[slug], and disabling stops blog rendering while stored D1 content remains. A page-derived navigation receives an automatic Blog link, while an authored navigation is edited through site_settings_update. The remaining flags are stored for upcoming capabilities and do not change rendered behavior yet. site_status reports the current feature state.

form_submissions

ChatGPT
Get form submissions for a site — submission data, timestamps, and read status. While no notification destination is configured (site_status email.notify_to), submissions land in storage only — no email is sent. Wire delivery anytime with email_setup; it applies to new submissions going forward (old ones are not replayed). Returns structured data in structuredContent.submissions: { items, total, has_notification_configured (boolean — whether delivery is wired; the human's email address is not exposed here), truncated (true when more than the 500 most-recent submissions exist), _warning }.

image_library

ChatGPT
Finds curated licensed stock photos matched to a business type and intended site role. The response includes a human-viewable gallery_url for picking and returns candidate image objects; a later content update places the selected image. Each candidate includes url, alt, category, width, and height. The complete object enables responsive WebP and AVIF output, and section_types identifies whether a section accepts a single image or an images array. The site renders the required provider attribution automatically. The response's source identifies an exact, fuzzy, parent, or generic match. A generic_fallback represents placeholder photography and is tracked through discovery_update until real or better-matched photos are available. image_search provides broader search when the curated set is insufficient.

media_panel

ChatGPT
Opens an interactive photo panel in the chat where the human picks image options and adds their own photos. Use it to see and pick image options, or to upload when no chat attachment reached asset_upload. Pass images from image_search or image_library to show as options, or omit for upload-only. Returns once the panel opens — the human's choices arrive LATER as a follow-up message or context update. Verify uploads with asset_list when they say they're done; ask which options they picked if a pick didn't come through. A photo reaches the site only after a content change places it. Where the panel can't render, share the returned upload_url.

schema_get

ChatGPT
Reads either the supported schema.org catalog or stored structured-data configuration. With no arguments, it returns recognized types and property allowlists. With domain, it returns the site-level Organization or LocalBusiness entity. With domain and page, it returns page-level configuration. inferred: true means no explicit configuration is stored and the platform will infer defaults at site_build, including a LocalBusiness subtype from category, Organization when no address exists, BlogPosting for blog posts, and FAQPage for pages with FAQ sections. schema_preview shows the rendered stored shape, and schema_set stores refinements based on known business facts. Read-only.

schema_preview

ChatGPT
Renders the stored site- or page-level structured-data configuration in the shape emitted by the build pipeline. Platform-managed joins-AggregateRating, Person[], OfferCatalog, Menu, BreadcrumbList, and Event[]-are applied during a build and are absent from this stored-config preview. The result supports review after site_build or schema_set and before site_publish. Read-only. Returns structuredContent.preview: { raw, rendered, note }.

schema_set

ChatGPT
Stores schema.org structured-data configuration for a site or page. domain selects the site-level Organization, LocalBusiness, or vertical subtype; adding page selects page-level types such as Article, BlogPosting, AboutPage, ContactPage, Recipe, HowTo, Event, or Product. Site-level and page-level entities merge at render time through @graph, so page configuration need not repeat site-level fields. Input consists of a supported type and its fields object. The curated registry rejects unknown types or properties with UNKNOWN_SCHEMA_TYPE or UNKNOWN_SCHEMA_PROPERTY. aggregateRating, review, breadcrumb, and FAQPage.mainEntity are platform-derived fields and are rejected with FIELD_IS_PLATFORM_DERIVED; their values come from relevant site sections and hierarchy. schema_preview displays the stored result, while platform joins appear during the build and site_deploy refreshes the preview site.

schema_validate

ChatGPT
Run schema validation against the site or page config. Returns a structured issues array (each entry: severity, code, message, suggestion). Empty issues + ok:true means the config is clean. Errors block emission of the rich-result; warnings are missing-but-recommended fields that don't disqualify the snippet but reduce its visual richness. Call before site_publish to catch AgentBuild registry errors and warnings (local validation, not a Google live test). Read-only. Returns structured data in structuredContent.validation: { issues, ok, note }.

section_types

ChatGPT
List all section types, variants, and their props. Call this when you need to know what sections are available for building pages. Returns the complete component vocabulary.

site_analytics_summary

ChatGPT
Returns first-party, cookieless site analytics for questions about traffic, leads, and performance: pageviews, leads, top pages, top referrers, top countries, device breakdown, and raw current-versus-previous-period counts. Full results appear in structuredContent.analytics, and the text body is a brief relay-safe summary. Leads and conversions are the primary small-business outcome, with traffic as supporting context. Counts describe observations rather than proving that a site change caused them; plausible context can include seasonality, ad spend, or search indexing. Neutral summaries and optional follow-ups avoid attributing wins to the agent. unique_visitors is approximate because it uses same-day grouping without persistent visitor IDs. has_data=false means no traffic is recorded for the period, and site_status provides site-health context when that is unexpected. Chart output is unavailable. Supported periods are 7d, 30d, 90d, month_to_date, and last_month, with 30d as the default. Related reads include form_submissions, tracking_add, and site_status.

site_build

ChatGPT
Builds the draft of a site created with site_create: applies its theme, stores pages, brief, and DiscoveryChecklist, and deploys the preview at {slug}.agentbuild.site. site_publish later takes the stored content live. A first build requires the human's answers recorded with discovery_update: business_name answered with the name in its note, plus two other answered items. This call's arguments never count; answers the human already gave count once recorded. Missing answers return DISCOVERY_INCOMPLETE naming them. A site that has a build rebuilds without this check. Every build needs at least one page and the preset the human chose, or the template they chose, which supplies both plus its fonts, colors and nav/footer. Unknown facts become tracked placeholders; copy uses the public business voice. Answered brand facts auto-apply: hex brand colors, and a purpose: "logo" asset when discovery reports a logo. The response says what applied; site_status.unapplied_discovery lists detectable gaps. Empty sections get the human's facts, photos and [Add: …] prompts that block site_publish; reviews, FAQs, figures and hours stay out until real. section_types supplies section shapes and image_library supplies candidate photos. nav_items seeds an authored primary navigation; the fallback derives navigation from pages, with the logo linking home. If only the deploy leg fails, site_deploy resumes it; a partial build names each failed write's recovery tool. Another site_build for the same slug enters update mode: matching pages are replaced, the theme is reset from the preset (with template, nav and footer too), only supplied navigation fields are overwritten, and the preview is redeployed.

site_create

ChatGPT
Create a new website with hosting infrastructure. Returns the site slug that all subsequent tools take as their domain parameter. site_build is the one-call alternative that also adds content, applies a theme, and deploys a preview.

site_delete

ChatGPT
Permanently delete a site and all its resources. This cannot be undone. Only use when explicitly asked.

site_deploy

ChatGPT
Refreshes the preview site at {slug}.agentbuild.site after stored content or theme changes. The live custom domain remains unchanged until site_publish. Builds take 30-45s, up to 90s — or 2-5 min cold-start after a platform update. A brief progress update before the call keeps the human informed. content_update writes are instant while the build is the expensive step, so related edits are most efficient as one batch followed by one preview refresh per milestone. In-flight work is coalesced and returned with status guidance; site_status reports deployment progress. After completion, site_screenshot is useful when the journey calls for visual verification. Human-facing updates identify this result as the preview, not the live site.

site_list

ChatGPT
List all sites in the account. Use this to see what sites exist, check their status, or find a site slug. Returns structured data in structuredContent.sites: { items, total, account }.

site_publish

ChatGPT
Publishes the site's current stored content to the live site at its verified custom domain. The preview site is the review surface and is expected to be current and approved first. Publishing is a reviewed milestone rather than an edit-by-edit step and usually takes 25-35 seconds. The first publish to each custom domain requires the human's verbatim approval in human_authorization; later publishes to the same domain reuse that consent artifact. More than three discovery placeholders require the human's approval and confirm_despite_placeholders: true. Sites with custom-code sections require disclosure that those sections are best-effort owner code and confirm_custom_code: true. Template-draft [Add: …] prompts block publishing (DRAFT_COPY_REMAINS, no override). After domain_verify, TLS may need 2-5 minutes. tls_provisioning means only the certificate is outstanding: retry after retry_after_seconds with the same arguments — no rebuild; the retry resumes at the certificate check (result field rebuilt). First apex publish adds the www → apex 301.

site_rollback

ChatGPT
Restores the live custom domain to a previously published Cloudflare deployment, usually within about 25-35 seconds. The preview site and stored D1 content remain unchanged. Rollback changes the published artifact, not the current content. Later site_publish operations rebuild from current stored content, including edits made after the selected version. Restoring the older content itself is a separate content_update. A verified custom domain and a targetable deployment are required. site_status.recent_deployments lists recent version strings and their rollback_targetable state. Versions published before deployment IDs were captured return rollback_unavailable; their recovery path is a content correction followed by site_publish. A brief progress update before the call identifies the selected version and expected wait.

site_screenshot

ChatGPT
Captures a static screenshot of the human's own AgentBuild site and returns a base64 image. It is useful after deployment for verifying visual changes; arbitrary external URLs are outside its scope. Cloudflare edge caches may need 10-15 seconds after site_deploy or update_and_deploy. During that window, edge_cache_pending indicates a capture race rather than a failed deployment. A new site's ssl_provisioning_pending may need 30-60 seconds. When Browser Rendering is unavailable, the response contains the site URL instead. A screenshot shows only the final painted state, not entrance motion, hover states, or scroll-triggered behavior. theme_get and site_status report the resolved animation tier. An unexpectedly blank region may also be a capture limitation; content_get and site_status provide corroborating state before any content-removal decision.

site_settings_get

ChatGPT
Reads the site's current navigation, footer, and logo settings. A null result means no explicit chrome settings exist and template defaults will render. site_build can seed these settings, and site_settings_update handles later free-form edits. Chrome state is separate from theme_get design tokens and content_get page content. Returns SiteChromeSettings or null in structuredContent.settings.

site_settings_update

ChatGPT
Partially updates the site's navigation, footer, and logo; omitted fields remain unchanged, and null restores a layout field's default. nav_items stores the authored editorial link selection. The navigation CTA can use an explicit nav_cta_text and nav_cta_href, use automatic contact or booking promotion, or be suppressed with nav_cta_enabled: false. Changes persist immediately but remain absent from the preview site until site_deploy or update_and_deploy refreshes it. Theme tokens belong to theme_set, while page and section data belong to content_update. logo is the default monochrome mark; logo_dark_scheme supplies an explicit dark-surface variant, and a lone monochrome logo is automatically inverted on dark surfaces.

site_status

ChatGPT
Returns full site state for orientation and preflight: deployment, theme, features, navigation, launch_checklist, and page_summaries. page_summaries lists each page's slug, title, section types, and variants, providing structural context without separate content reads. Navigation state includes source=authored|fallback|floor and cta_mode=explicit|auto|off; auto promotes a contact or booking target when one exists. Two-lane fields distinguish the always-present preview_url from live_url, which is null until a custom domain is attached. preview_is_ahead_of_live reports unpublished preview changes, and domain_required_for_publish reports the custom-domain precondition. launch_checklist covers page_titles, meta_descriptions, og_tags, favicon, image_alt_text, heading_hierarchy, json_ld, and llms_txt. recent_deployments contains the five latest main-branch versions with { version, status, deployed_at, rollback_targetable }; rollback_targetable identifies versions accepted by site_rollback. The top-level url is a deprecated alias for live_url, falling back to preview_url.

site_unpublish

ChatGPT
Takes a site off its custom domain: it stops serving there, the domain detaches, and links and search results pointing at it break. Content, theme, form submissions, uploaded images and the shareable preview site stay, and the human keeps the domain at their registrar. domain_add_custom, then domain_verify, then site_publish puts it back. Each call carries the human's verbatim reply in human_authorization; a call without it returns the consequences to read them first.

site_validate

ChatGPT
Validates site content without building, typically in milliseconds. It detects invalid section types, missing required fields, unknown variants, and invalid style properties. Results appear in structuredContent.validation: { valid, errors, warnings, summary }, with field-specific recovery suggestions. With domain alone, validation reads the site's persisted D1 content. With pages, it validates an in-memory page array shaped like site_build input, providing structural preflight without a 30-90 second build. check_urls: true adds HEAD probes for image URLs and usually adds 0.5-3 seconds. In persisted mode, an authored-nav page absent from nav_items, the nav CTA, and the footer produces the non-blocking ORPHAN_PAGE_NOT_IN_NAV warning. The page remains reachable by URL, and this advisory never makes validation fail; site_settings_update can add a visitor-facing link.

support_escalate

ChatGPT
Creates a support case after the original error's suggestion and next actions, plus relevant checks such as site_validate, site_status, and content_list or content_get, have not resolved the problem. Filing requires the human's explicit consent: contact_consent: true records that approval, and human_said contains the human's exact verbatim reply. Frustration, ambiguity, or inferred preference is not consent. The response includes ticket_reference, sent_at, reply_to_email, message, and any warnings. The human-facing update explains that the team will reply to the account email, typically within one business day, and includes the ticket reference.

template_get

ChatGPT
Returns a template's structural recipe: pages, section order, variants, navigation and footer chrome, and collection shape. Templates contain scaffolding rather than business content: section content objects are empty, collection items arrays are empty, and content_mode is structural. Empty sections are automatically marked placeholder on the DiscoveryChecklist. site_build with template set to this id builds Draft 1 from it in one call: these pages, the preset, the recipe's fonts, colors and nav/footer, and draft copy for empty sections. Pass pages with it only to change the structure; section_types provides canonical field shapes and variants. The included preview_url is the human-viewable template preview. Returns structuredContent.template: { id, name, ..., content_mode, preview_url, pages, chrome, features, business_info, collections }.

template_list

ChatGPT
Lists available site templates with { id, name, description, category, preset, page_count, preview_url }. Each template supplies a complete structure for customization and a live demo site at {id}.agentbuild.site; the lookbook is at templates.agentbuild.it/templates. Returns the cards in structuredContent.templates.

theme_get

ChatGPT
Reads the site's persisted theme configuration, including preset, colors, typography, and style tokens. A site without an established theme returns null; site_build establishes the initial theme. The persisted result supports design descriptions and informed theme_set changes, while update_and_deploy leaves theme state unchanged. Theme metadata is design context rather than public section copy. Returns the full ThemeConfig or null in structuredContent.theme.

theme_presets

ChatGPT
Lists available theme presets with their colors, fonts, descriptions, per-preset preview links, and the gallery URL at templates.agentbuild.it/themes. The human-viewable previews provide a visual basis for selection before theme_set. Also returns palette_vocab, the palette_seed hue and mood words. Returns preset cards in structuredContent.presets.

theme_set

ChatGPT
Partially merges visual-theme settings; only supplied values change. Re-sending a copied theme or style block can overwrite unrelated site-wide settings. Presets and overrides compose. A preset supplies layout, typography, and its default palette, while supplied colors replace selected palette values. Brand colors saved during discovery are not applied until they are included here or applied by site_build. theme_presets describes the available design languages, and theme_get returns the current resolved settings. palette_seed generates the full palette from a hue and mood, contrast guaranteed; pass it or preset, not both. Typography accepts curated font slugs. locale controls language metadata and date formatting. Site-wide style tunes corners, shadows, borders, buttons, motion, and photo grade. Theme writes persist without deploying; site_deploy refreshes the preview. Custom-color responses may include non-blocking contrast advisories. A single call accepts all requested theme changes.

tracking_add

ChatGPT
Adds or replaces one site-wide analytics, conversion-tracking, or SEO-verification provider. Re-adding a provider overwrites its stored configuration, and update_and_deploy applies the change to the preview site. Supported configurations are: ga4 { measurement_id }; gtm { container_id }; gsc_meta { verification_code }; gsc_dns { verification_code }; meta_pixel { pixel_id }; tiktok_pixel { pixel_id }; google_ads { conversion_id, conversion_label? }; and plausible { domain }. GA4 and Google Ads share one gtag.js include when both are configured. gsc_dns writes an apex TXT record and requires a Cloudflare DNS zone. Without a zone, the response returns no_zone_for_dns_verification, and gsc_meta is the alternative. With a zone, gsc_dns covers subdomains without a preview refresh. Visible Instagram, YouTube, Spotify, or Cal.com embeds belong in page content through an embed section rather than this site-wide registry. Provider identifiers are server-validated, and each site supports up to 10 providers.

tracking_list

ChatGPT
Read the analytics, conversion-tracking, and SEO-verification providers currently configured on the site. Returns the configured array (each entry: provider type + its IDs) plus available_providers — the Tier 1 catalog showing required fields and format examples per provider. Empty tracking array on a new site is normal; the agent can offer the catalog to the human if asked. Read-only. Returns structured data in structuredContent.tracking: { tracking, available_providers, max_providers }.

tracking_remove

ChatGPT
Removes a configured tracking provider. Removing gsc_dns also attempts to delete its TXT verification record; a DNS cleanup failure does not block removal of the tracking configuration. update_and_deploy applies script removal to the preview site.

update_and_deploy

ChatGPT
Updates one content item and refreshes the preview site in a single 30-45 second operation. The live custom domain remains on its last published version until site_publish. Exactly one update mode applies. section changes one section in place by its section_id from content_get, the safe single-section edit that avoids re-sending the page. data replaces the complete stored data object. patch recursively merges objects, but arrays replace wholesale; a patched sections array therefore replaces the entire stored sections array and carries expected_revision from the read it was built from. A replacement dropping stored sections lists the dropped ids in confirm_section_removals after the human's go-ahead. The content ID comes from content_list or content_get. A brief progress update before the call accounts for the build wait. For several related edits, the efficient cadence is multiple content_update writes followed by one site_deploy; this compound operation fits a single final edit. In-flight builds may be coalesced with status guidance.

Capabilities

WritesInteractive

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/agentbuild"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/agentbuild)