Fine Structure

Attach or replace the app custom domain through the same Fine Structure Studio custom-domain flow. Returns exact DNS verification and routing records for the user to configure at their DNS provider.

Stage one file upsert or delete inside a change set. Does not modify the live app until apply_change_set. Paths follow the Fine Structure app file API, documented at https://finestructure.ai/api/mcp/docs.

Add a document to a notebook: plain text, or a file (PDF, Word, a spreadsheet, an image or audio) as base64. It is processed in the background (audio is transcribed); list_knowledge_documents shows when it is ready. The same file twice is recognised.

Write a note into a notebook; agents and apps answer from it like from a document.

Agency mode only. Create a client claim link for an existing app owned by the agent. The client must log in with the invited email before ownership transfers.

Agency mode only. Create or update a client record for an account-level agent. This does not create a verified Fine Structure user account and does not transfer ownership.

Agency mode only. Create a new app owned by the agent, start generation, and create a claim link for the client. Ownership transfers only when the invited client logs in with the same email and accepts the claim link.

Agency mode only. Inspect one handoff status without exposing the raw claim token.

Agency mode only. List client records and app handoff status for the authenticated agent.

Apply a staged change set to the app. Creates a Saved Version before applying. Blocks on validation errors unless force=true.

Redact the chosen findings of a scan: approved maps each document id to the finding ids to replace. The original text is kept, so revert_knowledge_redaction can undo it.

Retire a goal: its runner stops and never runs again, and the goal stays readable. Use this when the owner asks to delete a goal.

Remove a scheduled task from the agent's schedule. It never runs again and stays readable in the history. Use this when the owner asks to delete or cancel a task.

Retire a trigger: it never starts the agent again and stays readable. Use this when the owner asks to delete a trigger.

Ask a notebook a question; the answer comes from its documents, with sources. Waits up to 25 seconds for the answer, otherwise returns the query_job_id for get_knowledge_answer. Without chat_session_id a new conversation starts.

Connect a platform WhatsApp number to one of the account's agents, so the owner can message that number and reach that agent. Requires the owner to be verified first. Take phone_number_id from get_agent_whatsapp. A number already used by another account is still valid to connect: it answers only this owner's verified phone.

Cancel one run in progress, for example a reply the agent is still working on. Work it handed to other agents is cancelled with it. Take run_id from list_agent_activity or get_agent_task.

Check Fine Structure custom-domain verification and SSL status for the configured custom domain, then save the latest status.

Check whether a platform subdomain can be claimed before calling set_app_subdomain. Returns available plus a status of available, invalid, reserved, taken, current, or empty, with the exact reason. Pass app_id (an app you own) to have that app's own current subdomain reported as 'current' instead of 'taken'.

Compare the current app files to a Saved Version and return compact per-file diffs.

Compare two Saved Versions and return per-file additions, removals, modifications, and compact diffs.

Configure custom-domain redirect policy: primary domain, optional www/root redirect, and HTTPS enforcement.

Store safe non-secret integration metadata for an app. Use set_secret for API keys/tokens.

Confirm the 6-digit code the owner received on WhatsApp from start_owner_phone_verification. On success the owner is verified: agents can message them, and platform numbers become connectable.

Create a native Fine Structure A/B test between existing app pages. Use update_app first if a variant page still needs to be generated. Creates a Saved Version before the change.

Create an autonomous AI agent on the user's Fine Structure account: a standing worker, not a chat session. It gets the platform's default safe tool policy and its own email address, it can read and write the app database, and once the owner phone is verified (see get_agent_whatsapp) it can message its owner on WhatsApp and by email through the platform system channels. Pair it with schedule_agent_task for recurring work such as following up new leads on WhatsApp each morning, watching an app for runtime errors, or sending a weekly summary. Messaging anyone other than the verified owner requires a channel the owner connects in the Fine Structure Studio.

Give an agent a goal to pursue on its own. It works on it every interval_minutes, at most max_iterations times, under its own permissions, so a step can message people the agent is allowed to reach. Each step uses agent credits.

Create a whole team of agents from a template, wired to work together, optionally adapted to the owner's requirements and company name. The new agents start active with the platform's default safe permissions and can message only their verified owner until channels are connected in Fine Structure.

Add a trigger that starts the agent with these instructions: event (event_type such as lead.created, with an optional source), schedule (a schedule object) or watch. Each start is a run under the agent's permissions and uses agent credits. Its approval rules stay as set in Fine Structure, and a webhook trigger, whose URL is a secret, is made on the agent's screen.

Create a new application from a natural language prompt. The AI generates a complete web app with pages, components, styling, and data models. Returns a job_id - poll get_job_status to track progress. When the job is done, the app is ready.

Create a staged file change set. Add multiple file changes, validate them as one app state, then apply atomically.

Create/insert records in one app entity. Executes directly for the authenticated app owner and returns the created record ids.

Create an entity schema file in entities/<Entity>.json. Creates a Saved Version before writing.

Create a folder for notebooks, optionally inside another folder.

Create an empty notebook, optionally inside a folder.

Add a company-wide goal for the whole agent team to align to.

Open a request to the Fine Structure platform team: a bug, a feature request or a question about the platform itself (not about the user's app). Use it when something in the platform blocks you instead of working around it. Give a reproduction the team can run (invoke_function / curl / the exact tool call and result), what you expected, and how the team will know it is closed. Credential-looking values are redacted. Returns request_id and a Studio URL; the team's replies, status changes and deployments come back through get_platform_request / list_platform_requests. Limits: 20 per account per day, 32 KB.

Save a WhatsApp trigger for record-created events. It is saved switched off and messages no one. Switching it on is done by the owner on the app's Automations screen in Fine Structure.

Delete a native A/B test from an app. Creates a Saved Version before the change.

Delete exact records by ID or exact-match filters. Executes directly for the authenticated app owner; pass expected_count as a safety check to abort on a mismatch.

Delete one app secret by key.

Disconnect the owner's WhatsApp route from a platform number. Removes only this account's route; other accounts sharing the number keep theirs.

Switch a WhatsApp trigger off: new records no longer send its message. It stays saved.

Discard a pending staged change set without changing app files.

Get views, unique visitors, conversions, and conversion rates for an A/B test.

Read one agent: name, role, description, persona (its standing instructions), status, email address, WhatsApp number and which capability groups are switched on.

Read visible messages, answers and result links in an owned agent's conversation. Returns the newest page in chronological order. For older history, pass next_before_id as before_id. For new replies, omit before_id.

Check a durable task returned by send_agent_message or list_agent_tasks. Includes the latest execution status and pending approvals, including before a run starts. Task scheduling state is separate from run outcome. Read the conversation for the actual answer; accepted/queued is not completed. Approvals must still be decided by the owner in Fine Structure.

Read the WhatsApp state of the connected account: whether the owner's phone is verified, which platform numbers they can connect, and which conversations already route to which agent. Call this first whenever the user asks to talk to an agent on WhatsApp, and repeat its next_step to them.

Traffic analytics for an app's published site over a chosen window: total views, unique visitors, daily series, top pages, top referrer domains and device split.

Deep introspection of an app: entities, pages, settings, integrations, environment variables, and file structure. Use this to understand what an app contains before updating it.

Get the file tree for an app with paths and byte sizes.

Which of the owner's notebooks an app's AI may answer from, and the ones it could be given.

Return editor, preview, published path, subdomain, and custom-domain links plus whether each works for anonymous visitors, app users, or Studio users based on publish and auth settings.

Read the saved public HTML-shell identity: name, description, language and image URLs/dimensions. Same settings as Studio SEO/GEO.

Read recent server-side security audit events for an app.

Return safe security context for one owned app: owner id/email, Studio collaborators, generated-app members, route policies, entity policies, function policies, and recent security audit entries. Does not return secrets and does not grant access to other apps.

Get app overview: files, published state, URL, active jobs.

Which of the owner's agents and apps may use one connection (from list_connections).

Status of the account-level connections: Facebook, Google Drive, TikTok and the social accounts connected through Zernio (Instagram, LinkedIn and others), including any that need to be reconnected. refresh true asks Zernio for the live state.

The account's plan and both balances: build credits, which pay for creating and editing apps, and agent credits, which pay for agent runs.

Return SSL/certificate status and pending certificate validation DNS records for the app custom domain.

Return the exact DNS records and instructions required to verify and route the app custom domain.

Get all entity (data model) schemas for an app, with record counts. Each entity has fields, types, and relationships.

Get recent runtime errors for an app (last 20). Useful for diagnosing issues before updating.

Poll the status of an async generation job. Use this after create_app or update_app to know when the job is done. Returns status ('running' or 'done'), progress events, and result summary when complete.

Who opened, asked or changed the notebooks, newest first: people, apps and agents.

The state and, once ready, the answer of a question asked with ask_knowledge_notebook.

One conversation with a notebook: the questions and the answers with their sources.

Who can use a notebook: the apps that answer from it and the owner's agents it is connected to.

A notebook's overview: the summary written from its sources, document counts by state, and which sources are ready.

What was redacted in one document, by category and count, and whether the original was kept.

A notebook's automatic redaction policy for new uploads.

A sensitive-data scan: per document its state and what was found (category, the text, the suggested replacement, confidence), and what was applied.

Read every scenario in the owner's connected Make account and grade what moves to Fine Structure fully, partly or by hand. Read-only.

Get all pages in an app with their file paths and sizes.

Return a machine-readable Fine Structure / FSe2 guide for AI agents. Call this at the start of an MCP session to learn app files, entities, safe edit workflows, validation, publishing, A/B testing, secrets, and platform rules.

One platform request with its full history: team replies, status changes (open | triaged | in_progress | needs_info | deployed | wont_fix) and what was deployed (commit, time). Pass since=<ISO timestamp> to get only the events after it.

Return editor preview and published/public URLs for an app.

Return the recommended MCP tool sequence for a task type. Use this before creating apps, editing files, seeding data, publishing, setting up A/B tests, restoring versions, or configuring secrets/integrations.

What a WhatsApp trigger can use in this app: the owner's WhatsApp numbers and flows, and the pages, entities and fields that create records.

Download a public audio file (a recording, a podcast episode) into a new notebook and transcribe it there.

Return server-side preview context: URLs, persisted runtime/network errors, static clickable candidates, pages, and explicit live-browser availability.

Provision a generated-app runtime member with a role. This does not create a Studio collaborator, and the owner role cannot be assigned. password is required: ask the account owner which password the member should get. This tool never generates one, because a generated password would come back in the result and that is a live credential in the conversation transcript.

Run a backend function of an owned app exactly like the HTTP route and return its status and JSON. caller='owner' runs as the app owner; caller='anonymous' first evaluates the function policy as a public visitor and returns the 401/403 decision without running when access would be denied. Use it to verify a function (secrets, outbound calls, policy) before wiring it into the app.

List the platform A/B tests configured for an app.

What the account's agents did, newest first: each run with its agent, status, the tools it called, agent credits used and any error. Read the run's conversation with get_agent_conversation for the full answer.

Actions the agents are holding until the owner approves them, such as a message to a customer or a payment. Each comes with a plain description and a review link. The owner approves or rejects them in Fine Structure.

List recent visible conversations belonging to one of your agents. Use get_agent_conversation to read replies and results.

An agent's goals: objective, success criteria, plan, status, progress, current step and the background runner task that works on it.

What an agent has learned and kept: long-term facts and insights, newest first, optionally only those about one customer.

List scheduled tasks for one agent (or the whole account), including schedule, status and next_run_at.

Ready-made single agent templates: role, description and suggested persona, for create_agent.

What starts an agent on its own: event, schedule, watch and webhook triggers, with their instructions, status and last fire. A webhook's URL carries its secret and is shown only on the agent's screen.

List the AI agents on the user's account with id, name, role, status and FineMail address.

List an app's platform path, subdomain, and configured custom domain with verification, SSL, primary-domain, redirect, publish, and login-gating status.

List generated-app runtime users/members for an app. This is separate from Studio project collaborators.

List owned and accepted Studio-shared applications, newest activity first. Returns up to `limit` apps per call plus the total count; page with `offset` when the account has more. Accepted editors can edit shared source; viewers can read it. Publishing, records, domains and security administration remain owner-only.

What an agent could do with one third-party app once it is connected: its actions.

Every service the platform can connect, with whether this account has connected it, whether one-click sign-in is available, and its connections.