artifact-create
ChatGPTCreate a NEW artifact from files supplied directly in this MCP call. Never edits an existing artifact. Pass a path-to-UTF-8-text map in files. It becomes the artifact's first commit and is ready immediately. Use artifactType "app" (the default) for a web application, or "markdown" for a readable document. Inline projects are limited to roughly 100 KB and cannot contain binary files; there is no ZIP or external-upload flow on this MCP surface. To change an existing artifact, use artifact-explore and artifact-edit. To rename it or change its visibility, use artifact-update_metadata. To deploy it publicly, use artifact-publish only when the user explicitly asks. Returns the sessionId, initial revision, artifactUrl, name, framework, fileCount, skippedFiles, and the applicable preview URLs. Use the revision as artifact-edit's baseRevision for the first edit.
artifact-create_knowledge
ChatGPTCreate a NEW knowledge artifact from Anima's knowledge-base template. Returns a ready artifact; never edits an existing one. Call with no arguments, or with an optional name (defaults to "Untitled project") and workspaceId. No files, ZIP upload, framework, or artifact type are accepted. The template supplies the initial files and determines the framework. Returns the sessionId, initial revision, artifactUrl, name, framework, fileCount, skippedFiles, and applicable preview URLs. Share artifactUrl with the human. Use artifact-explore and artifact-edit to inspect and change its contents; both work entirely through MCP. Only use artifact-publish when the user explicitly asks for a public deployment.
artifact-delete
ChatGPTDelete an EXISTING artifact. Use this tool only when the user explicitly asks you to delete that artifact. Do not infer deletion from a cleanup request. The tool makes a reversible soft deletion. It hides the artifact from normal lists and access paths. It keeps the artifact's code, assets, history, database content, and domain assignments. MCP cannot permanently delete an artifact. The tool needs write access. Unpublish a published artifact before you delete it. If a publish is in progress, wait for the publish to finish. Then call artifact-unpublish. Then call artifact-delete again. Set sessionId to the ID of the artifact to delete. An authorized repeated deletion succeeds. Returns: { success, message }
artifact-duplicate
ChatGPTDuplicate (clone) an EXISTING artifact into a new, independent artifact. This copies the artifact's code, assets, and supported database content. If a supported database cannot be copied, the entire duplication fails and no usable copy is returned. It does NOT copy chat or custom domains. This is different from running git clone locally: git clone only creates a local checkout, while this tool creates a new artifact with a new sessionId. Requires sessionId for a readable source artifact that belongs to the caller's current team. Public, shared, or otherwise readable artifacts in other teams cannot be duplicated with this MCP v1 tool. You need write in the workspace the copy goes to. name is optional; the default is "<source name> (Copy)". Retry safety: duplication is not idempotent. If a call times out or its response is lost, list recent artifacts (workspace-list_artifacts) before retrying because the first call may already have created the copy. Returns: { success, sessionId, sourceSessionId, name, artifactType, artifactUrl, nextSteps } — plus playgroundUrl and previewUrl when the copy is an app or knowledge artifact; a markdown copy gets previewUrl only
artifact-edit
ChatGPTChange the files of an EXISTING artifact and commit them entirely through MCP. Read the files first with artifact-explore and pass its revision as baseRevision. All changes land as one commit: either every operation applies or none does. Prefer str_replace for focused text edits; use write, delete, and move as needed. A write accepts UTF-8 text or an inline base64 binary up to 256 KB. Larger external asset uploads are not available on this MCP surface.
artifact-explore
ChatGPTInspect the files of an EXISTING artifact: list them, search their text, read them, or review the commit history. Works with no shell, no git and no network access, so prefer it whenever you cannot run git. Pass the sessionId (the last path segment of a .../chat/<sessionId> URL). A canvasDraft field, when authorized, reports an uncommitted Canvas draft. Use action draft to inspect its projection overlay explicitly; ordinary reads remain committed files. Draft access requires write permission. Typical flow to change something: action "search" to find the file, action "read" for the files you will edit, then artifact-edit. Every response includes "revision", the artifact's current commit — pass it back as artifact-edit's baseRevision. Use action "read" with a "revision" to see how a file looked at an earlier commit (this is how you undo something). Assets — images, fonts, media — are readable too: action "read" answers with size, mime and oid under "asset": true whenever a file's bytes are not text, instead of content. That check is on the bytes, so it is the authority: an SVG reads as text, and a file with an unfamiliar extension may still come back as an asset. When a search comes back empty, check "notSearched": "assets" counts binary files a text query can never match, and "excluded" counts files under node_modules, dist or build — re-run with includeExcluded true to search those. A "tree" listing also maps any path artifact-edit cannot change under "unwritable". For generation or build progress use artifact-status instead; this shows the commit log, not build state.
artifact-publish
ChatGPTPublish an artifact — deploys its committed files (git HEAD; uncommitted edits are not included) to a live public URL. Works for app AND markdown artifacts; an asset artifact cannot be published (tell the user so and share its artifactUrl instead). Publishing makes the content PUBLIC to the world. It is NOT needed for sharing — the artifact is already visible at its artifactUrl to everyone who can reach it, and liveUrl is NOT an editor. Call this only when the user explicitly asked to publish/deploy; otherwise share that URL and offer publishing as a follow-up question. Requires a sessionId from a previously created artifact (via artifact-create). What goes live: - app: the running web application. - markdown: one document. liveUrl renders the initial file (README.md if present, else the first .md lexicographically); the raw source is at <liveUrl without the query string>/index.md (Content-Type: text/markdown) — give the user that path when they want the markdown. Other .md files are served raw at their own paths, each with a rendered .html sibling. ```mermaid fences render as diagrams; the .md keeps the fence. accTitle/accDescr label a diagram. Modes: - "webapp" (default): Deploys to a live URL; use it for both app and markdown artifacts. Returns { success, liveUrl, subdomain }. - "designSystem": NOT available over MCP — always fails with an enterprise contact link, whatever you pass. Do not offer it as a capability. Returns: { success, liveUrl, subdomain }
artifact-status
ChatGPTCheck the build status of an EXISTING artifact (from artifact-create). Read-only. Generation is asynchronous, so this is how you find out it finished. Call it with { sessionId, wait: true } and it WAITS for you: the call returns as soon as status is 'ready' or 'failed', or after about 45 seconds still 'generating'. Then, you can call it again. This tool is meant to be called right after artifact-create, before replying to the user, and keep getting called until status is no longer 'generating'. ONLY when you want an instant snapshot, this tool can be called without wait (or false); the idea is to never spin on wait: false. Requires sessionId — the id returned by artifact-create (or the last path segment of an artifact URL like https://app.agentgrid.io/artifacts/<sessionId> or https://dev.animaapp.com/chat/<sessionId>). Returns: { success, sessionId, status: 'generating' | 'ready' | 'failed', progress (0–100, while generating), name, artifactUrl (generating/ready only), playgroundUrl (app and knowledge artifacts only, generating/ready only), previewUrl (app, knowledge and markdown artifacts only, generating/ready only), error (when failed), nextStep (when a wait returned still generating) }
artifact-unpublish
ChatGPTTake an EXISTING published artifact offline — clears its live URL so the deployed site (app or markdown document) stops being reachable. The inverse of artifact-publish. This only affects the live deployment: it does NOT delete the artifact, its code, or its content, and the same subdomain is reused if you publish again later. Requires sessionId — the id of an existing, currently published artifact (returned by artifact-create; if you have an artifact URL like https://app.agentgrid.io/artifacts/<sessionId>, it is the last path segment). Fields: - sessionId (required) — the artifact to unpublish. Returns: { success, message }
artifact-update_metadata
ChatGPTUpdate an EXISTING artifact's display name and/or visibility. This changes metadata only, never its files. Use artifact-explore and artifact-edit for content changes, artifact-publish for an explicitly requested public deployment, and artifact-create for a new artifact.
review-list
ChatGPTRead the change requests humans have addressed to YOU on their artifacts. A review is a batch of comments a reviewer wrote together and sent as one, each pinned to a place in the artifact. Call this when a human says they left you comments or asked for changes, and at the start of work on an artifact you have been reviewed on before. Every comment carries an anchor. For an app artifact that is dom: sourceFile with sourceStart/sourceEnd points straight at the code when it resolved, and instanceCount above 1 warns that the markup is SHARED — changing the component changes every instance, so change the one instance unless the reviewer meant all of them. For a document it is markdownRange: find the text by SEARCHING the markdown for quote (with prefix/suffix to tell repeats apart), never by the offsets, which any edit above them invalidates; headingPath says which section it is in, and endQuote with spansBlocks marks a comment covering several blocks. isLatest false means the artifact moved since the review was written — pull and judge whether the comments still apply before acting. You see the comments addressed to you, plus any addressed to nobody, which arrive marked unassigned: a review may hold comments for several agents, and another agent's are not yours to act on or report on. An unassigned comment is anyone's to take: reply to say you are taking it, which announces the work but does not reserve it — the comment stays open to every agent, and another may be working the same one. A comment addressed to PEOPLE and not to you never reaches you at all. A comment may name several parties, agents and people together. alsoAsked lists everyone else it names, so you can see a colleague is on it and not redo their work. Any of them may resolve it, and resolving closes it FOR ALL OF THEM. The mentions in the body may scope parts of the request — "@you fix the header, @someone else the footer" — and that scoping is in the words, not in the fields. So when you have done only your part, REPLY rather than resolve: resolving would close the others' half too, and they would never learn it was dropped. A comment may point at nothing in particular — that is the reviewer's note about the artifact as a whole, and it carries no anchor. Each comment carries its own status and replies, the conversation so far. READ THE REPLIES before acting: they may answer a question you asked, and they may also add or change what is being asked for, since a reviewer can keep talking after sending. The comment body is where the request starts, not necessarily where it ends. To resolve, copy the review's resolveTrailer into your commit message — it is the exact lines that close these comments, one per comment. Drop the lines for any comment the commit does not address. Use review-resolve when no commit will, and review-reply to say something without closing it.
review-reply
ChatGPTSay something back on ONE review comment and LEAVE IT OPEN — to ask what the reviewer meant, to report what you found, or to say you are blocked. Use this rather than review-resolve whenever the exchange is not finished: resolving closes it, and the reviewer would have to open a new comment to answer you. The reviewer sees your message in the artifact, and their answer comes back on the same comment — call review-list again to read it. They may not reply immediately, so do not wait on it. You may reply to a comment addressed to you, or to one marked unassigned. A closed comment takes no more replies — it answers replied: false, because nobody is reading that thread any more. Use mentionUserIds to bring a PERSON into the comment when you need a human decision, an approval, or information you cannot get yourself: pass the id of anyone in the artifact's mentionablePeople from review-list — they need not already be on the comment. Each person named is emailed, so name somebody only when the exchange genuinely needs them. You cannot mention another agent.
review-resolve
ChatGPTClose ONE review comment WITHOUT a commit — for what a commit message cannot carry: a question answered, or a deliberate decision not to make the change, explained in note. When a commit does address the comment, prefer the trailer AgentGrid-Resolves: <reviewId>#<index> in its message: that records which commit resolved it, which this cannot. Closing ends the exchange — if you are asking the reviewer something rather than answering them, use review-reply instead, which leaves the comment open for them to come back to. You may close a comment addressed to you, or one marked unassigned. Safe to retry — a comment already closed answers resolved: false rather than failing.
workspace-list_artifacts
ChatGPTList the artifacts you can read, most recently updated first, across every workspace you can access. Takes no parameters. Each row's session id is what artifact-explore and artifact-edit take, and each row names the workspace its artifact is filed in — that workspaceId is what artifact-create, artifact-create_knowledge, artifact-duplicate and workspace-move_artifact take, and this surface serves no workspace listing of its own. Rows cover only what you can access, and the listing is capped (truncated: true means more exist): report what you found, never a total, and never say the team has no artifacts.
workspace-move_artifact
ChatGPTRe-file an EXISTING artifact under a different workspace of the same team. The content stays put: the same git repository, sessionId, URL, history and live deployment. What changes is where it is listed and who reaches it — the destination's access decides that from here on, handing the artifact to the people who reach that workspace and taking it from the rest. Say what a move will change before making one a human did not ask for. You need write on the artifact AND write in the destination. Moving an artifact where it already is succeeds and leaves everything as it was. Returns: { success: true, sessionId, workspaceId, workspaceName, nextSteps }.
