MCP App Store
by KeenEthics
Corte icon

Corte MCP Server for ChatGPT

By Eli Makes, LLC

Overview

Corte is an AI media platform: create, edit, automate and publish brand media in one workspace. Connect it and describe the outcome; ChatGPT does the work in your Corte projects. Create: generate images, video, music, voiceover and sound effects in your brand's look and voice. Run one-click Applications like Product Reshoot and Virtual Try-On on your own photos. Automate: start any of your Workflows, follow the run, and get the results back. Publish: get a permanent public link for any asset. Create, translate and publish content. Spin up a Build site or app, talk to it, and deploy it. Grow: draft social posts and campaigns for review, and see how they performed. A person approves or schedules social posts in Corte before anything is sent to a connected channel. Turn a product catalog into ready-to-run ads. Follow your agents: see what your Corte agents did on each run and what they made. Stay in control: everything lands in the project you choose, and shared projects bill the project owner. You approve exactly what ChatGPT can reach when you connect, and you can disconnect it anytime from Corte's Settings.

How to connect

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

Tools

accept_brand_direction

ChatGPT
Make one candidate direction the project’s brand: its doc, tagline and pictures become the brand and the session is marked accepted. Only for a project whose brand is still empty — a project that already has a brand is changed through import_brand, which reviews every field. Refused while the session is running or when it failed. Returns the saved brand and its DESIGN.md. Ask the person which direction they want before calling this.

apply_brand_import

ChatGPT
Make a ready import part of the project’s brand. By default every changed field in the import’s diff is applied; pass paths (values of diff[].path from get_brand_import, e.g. "colors.tokens[primary].value" or "overview.tagline") to accept only some of them — paths not in the diff are ignored. Refused while the import is still running or when it failed, and with a conflict when the brand changed since the diff was computed (fetch the import again and retry). Returns the saved brand and its DESIGN.md. Confirm with the person which fields to apply before calling this.

cancel_agent_run

ChatGPT
Stop a run that is still in flight. The run ends as canceled and spends nothing further; what it already did stays done, and its outputs stay where it put them. Only a run that is queued, launching or running can be stopped — asking to cancel a finished run is refused with the state it is already in, so read the run first (list_agent_runs or get_agent_run) when in doubt. Only the agent’s owner can stop its runs. Returns the run as it now stands.

cancel_project_invite

ChatGPT
Withdraw an invite that has not been accepted yet, so the address can no longer join. Owner only. Takes the invite id from get_project’s invites (or the one invite_to_project returned). Withdrawing an invite that was already accepted does nothing — remove_project_member is the tool for someone who is already in.

cancel_workflow_run

ChatGPT
Stop a workflow run that is still running. Steps already finished keep their results and stop being billed further; the run settles as "stopped" within a few seconds, so the row returned may still read "running" — get_workflow_run shows it settle. Stopping a run that already finished changes nothing. Only the person who started a run can stop it.

commit_upload

ChatGPT
Finalize a direct upload once the bytes are in storage; returns the object with its links, ready for generate, run_application or publish_asset.

create_ad_set

ChatGPT
Start one of your ad sets of product ads — a batch of ads in one look over some catalog products, made in Corte (not a Meta Ads ad set; those are the meta_* tools). styleId is "brand" (the project’s Brand) or a house style from list_ad_layouts. Sizes default to 4:5 and 1:1; every fitting layout is built unless layoutIds narrows it; designsPerProduct AI-designed ads are added per product and size. Returns the ad set with its public feed URL for Meta/Google/Pinterest catalogs.

create_brand_directions

ChatGPT
Create a brand from a brief for a project that has no brand yet: three distinct candidate directions ("worlds"), each a complete identity — palette, type, photography direction, voice — with a generated hero picture and an ad picture, a tagline, an ad headline and a first social caption. The brief needs what (what the company makes or does) and feel (one to five words people should feel); audience, name (the model proposes one when empty), tasteUrl (a site whose taste to lean toward) and avoidUrl (one to be unlike) are optional. Spends the project owner’s credits (needs at least 90 available) and runs in the background: waits up to waitSeconds (default 60, max 300; 0 = return at once) and returns the session either way. When session.status is "ready", session.worlds holds the directions, each with a hero and ad link to show the person; still "running"? Poll with get_brand_directions, watching session.stage and session.detail. Nothing is saved to the project until accept_brand_direction.

create_build_app

ChatGPT
Create a new Build app and hand its coding agent the brief — the whole "New app" step in one call. The brief is the first message on the app’s builder thread, exactly as if the owner had typed it, so write it as a complete brief: what the site is, for whom, the look, the sections, any media direction. When a platform skill fits (list_skills / get_skill), answer that skill’s interview questions inside the brief so the builder can start without asking. Starts a sandbox and spends the owner’s credits. Returns immediately: follow with get_build_thread (waitSeconds) for the builder’s replies and questions, then trigger_deploy once a checkpoint exists.

create_content_document

ChatGPT
Create a content document. draft holds field values keyed by field name — media as {"storageId":"…"}, references as {"documentId":"…"}, localized fields as a locale map {"en":"…","de":"…"} (a bare value counts as the default locale). Rich text (portableText) is an array of nodes: text as {"_type":"block","style":"normal"|"h2"|"h3"|"h4"|"blockquote","children":[{"_type":"span","text":"…","marks":[]}],"markDefs":[]} (list items add "listItem":"bullet"|"number"; marks are strong/em/code or a markDef key for a {"_type":"link","_key","href"}), and an inline image as {"_type":"image","storageId":"…"} — a storageId from upload_asset or the library, never a URL or asset reference. _keys are optional. The document starts unpublished; use publish_content_document to make it live.

create_content_type

ChatGPT
Define a content type. name is the machine name (camelCase, immutable — it is the GraphQL identity and the delivery type= value); title is what editors see. Field types: string (opt. enum), text, number, boolean, datetime, portableText, media ({storageId}), reference ({documentId}, needs to: [typeName]), object (nested fields), embed (target: another type’s name, its shape stored inline), array (of: ONE field definition every item shares — an object, never a list, e.g. {"name":"authors","title":"Authors","type":"array","of":{"type":"reference","to":["author"]}}; a list of lists is not allowed, nest an object). Set titleField to the field that names documents in lists. Reference targets must already exist in the project. A string, text, portableText or media field may set localized: true — its value is then kept per locale ({"en": …, "de": …}) across the locales in get_content_settings.

create_growth_campaign

ChatGPT
Start a campaign to group a set of posts — name it for the story it tells ("Spring lookbook launch"), optionally with a description and the content document it centres on. Returns the campaign; pass its id as campaignId when drafting the posts.

create_growth_post

ChatGPT
Draft a social post into the Growth queue. By default it lands in pending_review: the person sees it in their review lane with the text, media and your suggested time, and approves, edits or declines it there — approval is the one step a tool cannot take, so tell the person the post is waiting for them rather than that it is scheduled. Pass state "draft" instead to park it unreviewed for someone to finish in the composer. Write the text platform-native for the channel (list_growth_channels) — it is checked against that platform’s limits and refused with the reason when it would not post. Media are library asset ids; links in the text become tracked links so get_growth_post_analytics can count clicks. Returns the post with its postUrl.

create_project

ChatGPT
Make a new project owned by the caller — a workspace whose media, cuts, workflows and generations sit together, with its own members and its own spend history. The caller pays for work done in it unless it is created in a team whose wallet pays. Returns the project (its id is what every other tool’s projectId takes), the member list (just the caller, as owner) and a link to the app’s project page. Do not create a project the person did not ask for: most work belongs in the one they already have, and list_projects shows what exists.

create_upload

ChatGPT
Reserve a direct upload for a file the person dropped on an inline view: returns a storageId and a signed url to PUT the bytes to; commit_upload then finalizes it. For views only — an agent with a URL uses upload_asset.

create_workflow

ChatGPT
Save a new workflow — a reusable pipeline of generation steps the person can open on the Corte canvas, run from the app, run through run_workflow, or hand to an agent. Compose the graph from a description using the node types in list_workflow_node_types: prompt and media input nodes feeding generate nodes, ending in an output node. The graph is checked before saving (unknown types, dangling edges, mismatched ports) and every problem comes back at once, so fix and resend rather than guessing. Saving is free; running spends credits. Returns the saved workflow with its id, the graph as stored, and a workflowUrl to show the person. Lands in the account’s default project unless projectId names a shared project the caller belongs to, in which case every member can see, edit and run it.

decline_growth_post

ChatGPT
Decline a post that is awaiting review: it leaves the review lane and stays as history in state declined, never published. Only a pending_review post can be declined — anything else answers with its current state. Use it when the person says no to a draft, or to withdraw one you queued by mistake; to remove the record entirely use delete_growth_post.

delete_agent

ChatGPT
Delete an agent for good: its definition, its schedule and event subscriptions, its standing credential, and its entire run history including replies and transcripts. A run still in flight is stopped first. What the agent made — documents, posts — is not touched; only the agent and the record of its runs go. This cannot be undone and there is no archive: to stop an agent without losing it, use update_agent with enabled: false instead. Only the agent’s owner can delete it. Confirm with the person before calling this unless they asked for the deletion in so many words.

delete_agent_memory

ChatGPT
Remove one note from an agent — how a person corrects an agent that learned something wrong, or withdraws an instruction they gave it. Takes the note’s id from list_agent_memories. The agent may learn the same thing again from a later run if the reason it learned it is still there; deleting the note fixes the note, not the cause. Owner-only.

delete_content_document

ChatGPT
Permanently delete a content document, its draft, its published copy and its full revision history. This cannot be undone — confirm with the user before calling it, and prefer unpublish_content_document when they only want it off the live site. Refuses when another published document references it; force:true deletes anyway and leaves those references dangling.

delete_content_type

ChatGPT
Permanently delete a content type and every schema version of it. This cannot be undone — confirm with the user first. Refuses outright while another type embeds this one (fix those fields first). Refuses while documents still use it unless force:true, which DELETES THOSE DOCUMENTS TOO — call list_content_documents first, tell the user how many will go, and only then force.

delete_growth_campaign

ChatGPT
Delete a campaign. Its posts survive — they are simply no longer grouped — so nothing scheduled is affected and nothing published is lost.

delete_growth_post

ChatGPT
Remove a post from the Growth queue for good. A scheduled post is pulled back first so it cannot go out; a post whose send is already in progress cannot be deleted. Deleting a published post removes Corte’s record of it, not the post on the platform. Prefer decline_growth_post for a reviewed draft the person said no to — that keeps the history.

delete_workflow

ChatGPT
Delete a workflow and its run history. Cannot be undone; the media its runs produced stays in the library. Only the creator or the project owner may delete one. Confirm with the person before calling this for anything they did not just ask you to remove.

generate

ChatGPT
Submit a generation job on any Corte model. params must match the model kind — image: {kind:"image", prompt, aspectRatio, resolution?, numImages?, referenceStorageIds?}; video: {kind:"video", prompt, duration, aspectRatio, resolution?, sourceVideoStorageId?, startFrameStorageId?, endFrameStorageId? (models with supportsLastFrame — pins the final frame, so two clips can be chained frame-identically), referenceImageStorageIds?, referenceVideoStorageIds?, referenceAudioStorageIds?, generateAudio? (false = video-only file, on models with supportsAudioToggle)} — LIP SYNC is a video model (sync-lipsync): sourceVideoStorageId = the clip, referenceAudioStorageIds = [the voice track], prompt optional; audio: {kind:"audio", prompt?, voice?, lyrics?, instrumental?, styleInstructions?, durationSeconds?, sourceStorageId?, videoStorageId?, targetLanguage?} — audio models carry a category in capabilities: tts (prompt = the words to speak — write pronunciation into the script itself, e.g. “Kimi (KEE-mee)”, since there is no separate direction field; shape delivery inline with interjection tags — (laughs), (sighs), (clears throat), (gasps) — and timed pauses as <#0.5#>; voice: OMIT it to speak in the brand’s default voice, name another of the brand’s voices (list_models’ brandVoices) to use that one with its delivery, and pick a stock voice from voices only when the person asks for one or the brand has none), dialogue (two to four people talking — an interview, a podcast, a conversation — in ONE audio file: prompt = the script, one turn per line as “Speaker: words”, where each Speaker is one of the brand’s cloned voices by name (list_models’ brandVoices on that model) or a stock name from the model’s voices; only the spoken lines — no title, notes or stage directions; no tags, punctuation carries the pacing; no voice param; it renders at about real time, so a long script takes minutes), music (prompt = style; lyrics on models with supportsLyrics, instrumental on models with supportsInstrumental — a vocal-song model needs lyrics), sfx (prompt), cleanup (sourceStorageId = the noisy recording + durationSeconds, its length), dubbing (sourceStorageId or videoStorageId = the source, targetLanguage from targetLanguages); upscale: {kind:"upscale", sourceStorageId, durationSeconds}. Models listing resolutions in capabilities price per tier — omit resolution for the default (first) tier. Check list_models for valid values. numImages defaults to 1 and multiplies the charge: ask for one image unless the person asked to choose between options ("give me a few", "some variations") — filling a page means one generation per slot, not four takes of each. Waits up to waitSeconds, then returns the job either way (poll with get_generation). A finished job carries results[]: per result a storageId, a downloadUrl that opens for 24 hours without sign-in, and a libraryUrl that is permanent and opens the asset in Corte — show the person the libraryUrl. For a permanent public URL to embed anywhere, call publish_asset with the storageId.

generate_catalog_ads

ChatGPT
Make the ads for ONE product in an ad set (call once per product): every fitting library layout at every size of the ad set, plus AI-designed ads. Regenerating replaces the product’s unapproved ads and keeps approved ones. The product must be prepared first (prepare_catalog_product). Returns the new ads with their images, which layouts didn’t fit and why, and the credits spent.

get_account

ChatGPT
The authenticated account: plan (tier, price, monthly credit budget, renewal date, whether it is set to cancel or is past due), credits (remaining, purchased, spent this period, the first-top-up bonus still owed), storage (bytes used against the plan’s quota — a full quota blocks uploads and imports until files are deleted or the plan grows), and the gates that decide whether a spend goes through: emailVerified (an unconfirmed address cannot spend unless it has paid), hasPaid (any top-up or plan, which also unlocks the models list_models marks paidOnly) and suspended. Call it when the person asks what plan they are on, why something was refused, or how much room they have; for the balance alone, get_credits is cheaper and takes a projectId. Shared projects bill their owner, so this describes the caller’s own account, not a project’s payer.

get_agent

ChatGPT
Fetch one agent by id: its full prompt, the scopes it runs with, its schedule and time zone, the content events it subscribes to, whether it is enabled, and its lastRunAt / nextRunAt. Read this before update_agent — an update replaces the fields you send, so you need to know what is there. When an agent has a recipeId it tracks a curated recipe: the prompt you read back is that recipe’s current text, maintained by Corte and liable to change under the agent, not wording its owner chose. A null recipeId means the agent owns its prompt outright.

get_agent_run

ChatGPT
Read one run of an agent: its subject, the owner’s message, its report, what it made, what it cost (creditsSpent includes the media the run generated or transcribed; mediaCreditsSpent is that media share), and its transcript — use it to see what an earlier run actually did before continuing its thread.

get_asset

ChatGPT
Fetch one stored file by storageId: filename, content type, size, when it was added, a downloadUrl that opens for 24 hours without sign-in (plus a thumbDownloadUrl for images and video), and a permanent libraryUrl that opens it in Corte — the link to show the person. Use it to check what an id actually refers to before placing it in a document or handing it to a model. Only files the account owns or that are shared with it through a project are visible; anything else reads as unknown.

get_brand

ChatGPT
The project’s brand: a structured identity (overview, color tokens, typography families and levels, layout spacing/rounded/elevation, component tokens, photography direction with a generation-ready promptSuffix, voice and tone, logo rules, dos/donts) plus designMd, the same rendered as a DESIGN.md. Read it before generating on-brand images, copy or UI.

get_brand_design_md

ChatGPT
The project’s brand rendered as DESIGN.md (YAML tokens + prose sections) — drop it into a repo or a system prompt as-is.

get_brand_directions

ChatGPT
Fetch a brand-creation session by id: status ("running", "ready", "failed" or "accepted"), the current stage and detail while it runs, and once ready the three candidate directions in session.worlds, each with its id, title, rationale, full brand doc, copy, and hero / ad picture links. The polling tool for create_brand_directions; pass the same projectId the session was started in.

get_brand_import

ChatGPT
Fetch a brand import by id: its status ("running", "ready", "applied" or "failed"), progress stages, the extracted brand doc and — once ready — diff, the field-by-field changes against the project’s current brand. The polling tool for import_brand; pass the same projectId the import was started in.

get_build_app

ChatGPT
Inspect one Build app: the app itself, its current builder thread if it has one running, its most recent checkpoints and its most recent deploys. A checkpoint is a commit the app’s coding agent made — the newest one is first, and its sha is what trigger_deploy takes. A deploy carries its status and, once live, the public url. Use this to see whether a change you requested has actually landed.

get_build_thread

ChatGPT
Read what a Build app’s coding agent has said and done: its replies, a question it is waiting on (answer it with send_build_message), checkpoints it committed, errors, and the thread status (queued | provisioning | running | awaiting_input | completed | failed | cancelled). Pass waitSeconds to block until something worth reacting to lands instead of polling; pass the returned lastEventId back as since to read only what is new. This is the reply side of send_build_message and create_build_app.

get_content_document

ChatGPT
Fetch one content document: its draft and published payloads, status, and the schema it validates against. valid/issues report whether the draft would publish.

get_content_settings

ChatGPT
The project’s Content settings: its locales (code, title, fallback, required-for-publish), which one is the default/source locale, the translation settings (tone-of-voice brief, auto-translate on publish, model), and models — the translation models this project may choose from. Read this before adding a locale or translating.

get_content_type

ChatGPT
Fetch one content type by id or by machine name (e.g. "post"), with its field definitions. A name is looked up in projectId. Pass version for a historical schema.

get_credits

ChatGPT
Credit balance the work will spend from: the wallet that pays for the project — its owner’s, or the organisation’s — and the number that decides whether a generation there runs. Without a projectId, the account’s default project, where work that names none lands. Cheap — call it before expensive work, and again after the person says they have added credits.

get_generation

ChatGPT
Fetch a generation job by id: status, cost, and once finished results[] — per result a storageId, a 24-hour downloadUrl and a permanent libraryUrl (the one to show the person). publish_asset turns a storageId into a permanent public URL.

get_growth_campaign

ChatGPT
One campaign with every post in it (all states, newest first) and its combined performance: clicks and visitors across all its tracked links. analytics.enabled false means links are not tracked on this deployment and ok false means the read failed — neither is zero. Per-post engagement is get_growth_post_analytics.

get_growth_post

ChatGPT
One post in the Growth queue: its text and media, channel, campaign, state (draft, pending_review, scheduled, publishing, pending_platform, published, failed, declined), publish time, the live URL once it is out, and lastError when a send failed. Use it to check whether something you drafted was approved, and before update_growth_post to see what is there now. postUrl opens it for the person.

get_growth_post_analytics

ChatGPT
How one post landed: clicks and unique visitors on its tracked links (with a per-day series) and, where the platform reports it, the post’s own likes, comments, shares and views with the time they were read. Read the flags before quoting numbers: enabled false means this deployment does not track links at all, ok false means the click read failed — neither is zero clicks. metrics is null until the post is live or when the platform has no readable engagement; a missing field inside it means the platform does not report that number, not that it is zero.

get_project

ChatGPT
One project in full: its name and description, the caller’s role in it (owner or contributor), who pays for work done in it and the credits it can spend right now, every member with their role and email, and — when the caller owns it — the invites still waiting to be accepted. Use it before invite_to_project or remove_project_member (members carry the userId the latter takes), and whenever the person asks who is in a project or what it can spend. A project the caller is not a member of reads as unknown. Show the person the name, the role and the member list; the ids are for the other tools.

get_project_usage

ChatGPT
What a project has spent: its credit ledger newest first (each entry’s kind, credits, the member who spent them and when) plus, in totalsByActor, every member’s spend over the project’s whole history regardless of the page. The owner sees everyone’s spend; a contributor sees only their own. Pages with limit/offset and returns total, the number of entries visible to the caller. Use it to answer "what has this project cost", "who is spending the most" or "what did we do yesterday"; for the balance still available, get_project has remainingCredits.

get_site_analytics

ChatGPT
Read a deployed Build app’s web traffic: page views, unique visitors, views over time, top pages, referrers, countries and devices — collected on the live site itself, bots excluded. Use it to answer "how is my site doing" or to ground a change in what visitors actually do. events lists what happened in the window — deploys that went live and social posts whose tracked links point at this site (kind: deploy | post, actor: agent or human, with a summary) — so traffic moves can be correlated with releases and posts. Counts are estimates from sampled data, and visitors over multi-day ranges counts visitor-days (the count resets daily). ok: false means the analytics backend could not be reached — say so; it is NOT zero traffic.

get_skill

ChatGPT
One platform skill in full: its description, the interview section (the questions a brief should answer up front — for scroll-craft: subject and vibe, the belief and the action, the journey, the feeling curve and the peak, the signature-move seed, aesthetic range, one world or distinct scenes, existing assets; for scroll-world: subject, brand kit, art direction, camera, sections, mobile, resolution and media cap) and the complete procedure text. Read the interview, answer it in the brief, and the builder can start without asking.

get_transcription

ChatGPT
Fetch a transcription job by id: status, cost, and once finished the text, timed segments and srt/vtt subtitle strings. The polling tool for transcribe_asset.

get_usage

ChatGPT
What the account spent, by kind and by day, over a window — the account-level answer to "what am I spending on" and "what did that charge buy". Pass days (default 30) or an explicit from/to. Returns spentCredits and grantedCredits for the window, byKind (one row per ledger kind: generation, transcription, build_agent, build_compute, agent_run, agent_usage, topup, monthly_grant, adjustment, … with spent, granted and entry counts), daily (per-UTC-day spend bucketed into generations, agents, compute and other), and recent: a page of the activity feed, newest first, where one Build session or agent run is one line however many charges it settled (limit/offset over recentTotal — the feed covers the whole history, not just the window). Amounts are credits; 100 credits is one dollar. A shared project’s spend lands on whoever pays for it, so this shows what THIS account paid, including work its collaborators did; a single project’s own breakdown is on GET /v1/projects/:id/usage.

get_workflow

ChatGPT
Inspect a workflow: its nodes with labels and positions, its edges, and which node ids accept run inputs (prompt/generateText nodes take {text}; imageInput/videoInput nodes take {storageId}). graph is the full canvas.

get_workflow_run

ChatGPT
Fetch a workflow run: status, the workflow it belongs to, its nodes with labels, and per-node results — text outputs as text, media outputs with a 24-hour downloadUrl and a permanent libraryUrl.

import_brand

ChatGPT
Extract a brand identity (palette, type, layout tokens, photography direction, voice, logo) from an existing source and stage it as an import the person can review before it touches the project’s brand. Sources, by kind: "url" (default) reads a public https website; "figma" reads a Figma file (needs url = file URL or key, and the project's Figma connection — without one, ask the person to connect Figma in Corte's Settings); "html" takes raw markup; "screenshot" takes up to 6 committed image storageIds of a design; "designmd" parses a DESIGN.md document and costs nothing. Every other kind spends the project owner’s credits (at least 2 for a site, 5 for Figma or screenshots) and runs in the background: this tool waits up to waitSeconds (default 60, max 300; 0 = return at once) and returns the import either way. When import.status is "ready" the answer carries diff: the field-by-field changes against the current brand (path, label, before, after), which is what to show the person; nothing is applied until apply_brand_import. Still "running"? Poll with get_brand_import. Import ids are per project.

import_shared_reference

ChatGPT
Copy one shared reference into a project and return its storageId — the handle generations, applications and workflows take. Idempotent per project (re-importing returns the same copy) and quota-exempt.

invite_to_project

ChatGPT
Invite someone to a project by email. This SENDS them an email from Corte on the caller’s behalf and gives them, once they accept, contributor access to everything in the project — its media, cuts, workflows and content — with their work billed to the project. Owner only. Confirm the address with the person before calling; a wrong address is an email to a stranger. The invitee needs no account yet: the invite waits for them to sign up with that address. Projects hold at most 20 people, members and pending invites together. Returns the invite (its id is what cancel_project_invite takes); get_project lists the ones still open.

list_ad_layouts

ChatGPT
The ad layouts and house styles an ad set can use: each layout’s id, what it is for (a price drop, a review, a countdown, a word behind the product…) and what a product needs for it; each style’s id and look. Pass layout ids to create_ad_set or generate_catalog_ads to narrow a run.

list_ad_sets

ChatGPT
Your ad sets of product ads made in Corte (not Meta Ads ad sets — see meta_get_ad_sets for those): name, style, sizes, how many ads and approvals each has, and its feed URL. Paged.

list_ads

ChatGPT
The ads in an ad set, optionally for one product or one status (draft, approved, rejected): each ad’s image, layout, status and any issues the checker found. Paged.

list_agent_memories

ChatGPT
What an agent has learned and been told, strongest first — the notes every run is briefed with before it starts. Two sources: run notes the agent extracted from its own earlier runs, which fade with age (effectiveConfidence falls until injected turns false and the run no longer sees it), and user notes its owner wrote with add_agent_memory, which hold at full strength until deleted. The agent keeps its own notes tidy: after a run it rewrites a learned note the run refined and drops one the run showed to be wrong, rather than adding a near-copy. Read this when an agent keeps doing something wrong — a stale or mistaken note is usually why — and to check what a standing instruction already covers before adding another. Faded notes are still listed so they can be found and deleted. Owner-only.

list_agent_outputs

ChatGPT
Everything an agent has made across all its runs, newest first — the outcome view. Each output names what it is (kind: a content document or a social post), the id of that thing (refId), its title, what the run did to it (action: created, updated or published), which run did it (runId) and when. Use this to show a person what an automation has actually produced, or to find the document or post to open next: read a content document with get_content_document, a social post with list_growth_posts. Any member of the agent’s project can read this. Empty for an agent whose runs have only reported and made nothing yet.

list_agent_runs

ChatGPT
The run history of one agent, newest first: what each run was about, its status, what it made (outputs), how many credits it spent (creditsSpent, which includes the media the run generated or transcribed; mediaCreditsSpent is that media share), and — for a run that ended on a question — needsInput: true. Use this to answer "what has this agent been doing", to find a run to read in full with get_agent_run, or to spot one to answer with reply_to_agent_run. Statuses: queued, launching, running while in flight, then one of succeeded, failed, canceled, timed_out, skipped. statusDetail says why a run failed or was skipped. By default this is the channel view: top-level runs only, each with its replyCount. Pass threadRunId to read one run’s replies oldest first, or all: true for every run including replies. Any member of the agent’s project can read this; each run carries a url the person can open.

list_agents

ChatGPT
List the agents this account has created — standing automations that run a prompt on a schedule, on a content event, or on demand. Each entry carries the id the other agent tools take, its prompt, the scopes it holds, its schedule and time zone, whether it is enabled, and when it last ran and next will. Use it before creating anything, so you extend an existing automation rather than adding a second one that does the same job. When an agent has a recipeId it tracks a curated recipe: the prompt you read back is that recipe’s current text, maintained by Corte and liable to change under the agent, not wording its owner chose. A null recipeId means the agent owns its prompt outright.

list_applications

ChatGPT
List Corte Applications — curated one-shot generation experiences (e.g. Flatlay to Model, Product Images). Each lists its input needs (minImages/maxImages, inputKind, and referenceImages for video applications that also take photos — e.g. Recast), presets, and whether it accepts extra text.

list_assets

ChatGPT
List the media in a project — images, video and audio the user has uploaded, imported or generated. Returns each file’s storageId, filename, content type, size, a downloadUrl that opens for 24 hours and a permanent libraryUrl. A storageId is the handle everything else takes: put one in a content document’s media field, or pass it as a generation reference or a workflow input. Filter by kind ("image", "video", "audio") when you only want one sort.

list_brand_imports

ChatGPT
The project’s brand imports, newest first, with status, source label, cost and which fields were applied. Use it to find an import the person started earlier in the app or through the API before polling or applying it.

list_build_apps

ChatGPT
List the Build apps the user can work in — web apps Corte builds, hosts and deploys, in their own projects and in projects shared with them. Each entry has the appId the other build tools take, its name, its GitHub repo, its default branch and access: manage (the project owner or the app’s creator — may also change its address, secrets and database, or delete it) or edit (a contributor — may chat, build and deploy). Use get_build_app to see what an app has been doing.

list_catalog_products

ChatGPT
The products in the project’s ad catalog — title, price, photos and whether each is prepared for ads (cut-outs made and photos read). Search by title with q. Paged: total counts every match.

list_content_documents

ChatGPT
List a project’s content documents. Filter by type (machine name), status (draft | published | changed), q (searches the type’s title field; needs type) and missingLocale (documents with an untranslated top-level field in that locale; needs type). Each row carries locales: per-locale coverage (state complete | partial | empty | outdated, with the missing / outdated / machine-translated field paths) when the type has localized fields.

list_content_revisions

ChatGPT
History for a content document: draft saves plus publish/unpublish/restore steps, newest first.

list_content_types

ChatGPT
List a project’s content types (the CMS schema registry), each with its field definitions and how many documents use it.

list_growth_campaigns

ChatGPT
The project’s campaigns — each groups one story’s posts (a launch, an article’s social set) under a name so they can be planned and measured together. Use it to find the campaignId for create_growth_post and list_growth_posts, and get_growth_campaign for a campaign’s posts and combined clicks.

list_growth_channels

ChatGPT
The social accounts a project can publish to — one channel per connected platform (Bluesky, Mastodon, LinkedIn, Threads, Instagram, …), with its id, provider, handle and status. Call this before create_growth_post: a post needs a channelId, and the channel’s platform decides the character limit and media rules the post is checked against. A disconnected channel is one whose account link is gone — posts to it fail until the person reconnects it in Settings. Connecting a social account in Settings makes its channel appear here on the next call; a person removes one in Growth → Channels.

list_growth_posts

ChatGPT
The Growth publish queue: posts across every state (draft, pending_review, scheduled, published, failed, declined) with their text, channel, campaign and — where the deployment tracks links — per-post click counts (clicks; absent means untracked, not zero). Use it to learn what already went out and how it landed before drafting more, and to check whether something queued via a *_publish_post tool was approved. Approval itself is human-only, in the Growth review lane.

list_models

ChatGPT
List generation models (image, video, audio, upscale) with capabilities and credit pricing. Use a model id with the generate tool. Audio models carry category (tts, music, sfx, cleanup, dubbing) plus voices/defaultVoice, supportsLyrics, supportsInstrumental and targetLanguages; video models carry requiresSourceVideo (lip sync, video-to-video), maxReferenceAudios, supportsFirstFrame/supportsLastFrame. The speech model also carries brandVoices: the project’s own voices (Brand → Sound), the default marked — speech uses those before any stock voice.

list_projects

ChatGPT
The projects this account can work in — its own and the shared ones it is a member of — with each project’s id, name, role, and the credits it can spend (a shared project spends its owner’s). Every other tool’s optional projectId takes one of these ids; without one, work lands in and bills to defaultProjectId. Call this first when the person names a project.

list_shared_references

ChatGPT
Browse the platform's shared reference pool — curated imagery every account can compose shots with, e.g. the named casting portraits behind the Characters picker (category "character"). Each entry has an id, name, persona tags and a permanent public imageUrl. Pass an id to import_shared_reference to get a storageId usable as a generation reference.

list_skills

ChatGPT
The platform skills a Build app’s coding agent can run — packaged procedures for a kind of site or section (e.g. scroll-craft: a premium scroll-driven landing page where every act behaves differently; scroll-world: one continuous camera flight through generated scenes). Each has a name and a description of when it applies. Use get_skill for the interview a brief should answer, then mention the skill by name in the brief you send with create_build_app or send_build_message.

list_workflow_node_types

ChatGPT
The vocabulary for composing a workflow: every node type with what it is for, its input and output ports (id, type, whether optional or multiple), the data keys it reads and the values they take, which run_workflow input key overrides it at run time, and which list_models kind its modelId accepts. Read this before create_workflow or before changing a graph with update_workflow; the guide field states the rules a valid graph follows. Free, and the same for every account.

list_workflow_runs

ChatGPT
A workflow’s run history, newest first: each run’s id, status (running, complete, error, stopped), when it started and finished, who started it, and how many nodes have finished. Use it to find a run to inspect with get_workflow_run or stop with cancel_workflow_run, or to tell the person whether a pipeline has run before. Visibility matches the app: every member sees every run of a shared-project workflow; a personal workflow shows only the caller’s runs.

list_workflows

ChatGPT
List saved Workflows (node pipelines built in the Corte canvas) in a project — the account’s default project unless projectId is given. Same visibility as the REST API: every member’s workflows in a shared project.

prepare_catalog_product

ChatGPT
Ready a product’s photos for ads: cut the product out of each photo and read where the subject and the quiet space are, so layouts can put type behind the product and never over it. Optionally also shoot one styled scene of the product with room left for type. Costs credits per photo (and for the scene); takes up to a minute and a half.

publish_asset

ChatGPT
Publish a library asset to the public media host and get its PERMANENT public URL. Use this for any media a deployed site references — download links from get_asset and generate last a day, so never embed those. Publishing makes this one asset world-readable at a stable URL; idempotent, re-publishing returns the same URL. Ideal for generated video and imagery: publish, then reference the returned url directly in the app. Images come back with a resizeUrl template too: the same picture through the edge image resizer (…/cdn-cgi/image/width={width},format=auto,quality=82/pub/…) — put a pixel width in place of {width} for a thumbnail, a card or a hero without re-uploading anything; also fit=cover,height=… for a crop. Video is served as-is.

publish_content_document

ChatGPT
Publish a document’s current draft, making it live to the delivery API. baseVersion must equal the document’s draftVersion (from get_content_document) — a mismatch means someone edited it since you looked. Refuses if the draft does not validate against the current schema.

read_webpage

ChatGPT
Read web pages: pass up to 10 urls the person gave you or web_search found, and get each page's text back as clean markdown (fullContent, the default) or, with fullContent false, just the excerpts relevant to an objective. Use it whenever someone shares a link — an article to turn into a script, a product page, a competitor's site — instead of asking them to paste it. Pages that cannot be read (paywalls, blocks, dead links) come back in errors with a reason; say so plainly and search for another source of the same story before asking the person for the text. Costs 1 credit for up to six pages, 2 for more; nothing when no page could be read.

redesign_ad

ChatGPT
Have the AI designer rework one ad from a plain instruction ("make the price the hero", "warmer, more space around the product"). Small asks (copy, colour, sizes) change just those layers and come back in seconds; asks for a new layout redesign it from the current ad. Returns the ad and one sentence saying what changed, to pass on. The ad goes back to draft. Costs credits.

refresh_ad_set

ChatGPT
Bring one of your ad sets of product ads up to date after products, photos, the look, the offer or the copy changed: rebuilds the library ads whose inputs changed (same ads — approved ones stay approved and their feed image updates), adds layouts that now fit, and removes drafts that no longer do. Ads someone edited are left alone unless includeEdited. Free. Without productId it does as many products as fit in one call — call again while remaining is above 0. list_ad_sets shows what a refresh would change (refresh).

remove_project_member

ChatGPT
Take a member out of a project. They lose access to everything in it at once; what they made stays. The owner can remove any contributor, and a contributor can remove themselves (leave); nobody can remove the owner. Takes the member’s userId from get_project. Confirm with the person before calling.

retry_growth_post

ChatGPT
Send a failed post again, now or at a time you pass. Read lastError on the post first (get_growth_post): a retry only helps once the cause is fixed — a reconnected account, a platform back up. The words that go out are the ones a person already approved; a failed post cannot be edited. Only a failed post can be retried.

rewrite_product_copy

ChatGPT
Write a new headline and copy for one product in one of your ad sets of product ads, different from the current one, and put it into that product’s ads: library ads are rebuilt with it, AI designs get the new words in place (checked, and fixed if they no longer fit). Ads someone edited keep their words unless includeEdited. Costs credits: about 1 for the copy, plus any fixes.

run_application

ChatGPT
Run a Corte Application by id. Provide imageStorageIds (or videoStorageId / audioStorageId for video/audio-input applications) from upload_asset, optional text guidance, and an optional presetId. A video application with referenceImages takes those photos in imageStorageIds alongside videoStorageId; text names them as "image 1", "image 2"… in that order. A video application’s output runs as long as its source clip, and that length is what is billed — Corte measures it from the file, so durationSeconds is only a fallback for a file it cannot read. Waits up to waitSeconds for the generation.

run_workflow

ChatGPT
Execute a workflow server-side with optional per-node input overrides, e.g. {"inputs": {"concept": {"text": "…"}, "productPhoto": {"storageId": "…"}}}. Use get_workflow to find input node ids. To iterate cheaply, pass reuse: true — nodes whose settings and inputs are unchanged since your last run keep that run's results (free); rerun forces fresh takes of chosen nodes (and what they feed); only stops after the chosen nodes. Waits up to waitSeconds; if still running, poll with get_workflow_run.

send_build_message

ChatGPT
Ask a Build app’s coding agent to change the app, describing the change in plain language exactly as its owner would ("add a testimonials section to the home page"). The request is queued on the app’s builder thread and worked on asynchronously — this returns once it is accepted, NOT when the change is done, so do not treat success as the change existing. Poll get_build_app: a new checkpoint means the builder committed something. Opening a thread starts a sandbox and spends the owner’s credits. A committed change is not live until it is deployed.

sync_catalog

ChatGPT
Bring the connected store’s products (Shopify, Squarespace or BigCommerce) into the ad catalog: titles, prices, markdowns, colours and up to four photos each. Products already imported are updated in place and keep their prepared photos. Returns how many were imported and updated.

transcribe_asset

ChatGPT
Transcribe the speech in a stored audio or video file (a storageId from list_assets, get_asset, upload_asset or a generation) and get subtitles back: the full text, timed segments with speaker labels, and ready-to-save srt and vtt strings. Costs credits by the minute of audio, charged only once the transcript exists. The file’s length is read from the file itself; pass durationSeconds only if that fails and the tool asks for it. Waits up to waitSeconds for the transcript (default 120, max 300) and returns the job either way — if it is still running, poll with get_transcription. Word-level timings are on GET /v1/transcriptions/:id/result.

translate_content_document

ChatGPT
Machine-translate a document’s localized fields from the source locale into the project’s other locales and write the results into the draft (not published). mode: "outdated" (default) fills empty values and redoes machine translations whose source text changed since; "missing" fills empty values only; "all" also overwrites hand-written translations — confirm with the user before "all". Media fields are skipped. Costs credits (billed to the project owner); the response reports what landed per locale, what was skipped, and the credits spent.

trigger_deploy

ChatGPT
Deploy a Build app, publishing it to the real url the public visits. Omit checkpointSha to deploy the app’s newest checkpoint, which is the usual intent after asking the builder for a change. Deploys are queued: the response reports the deploy as it starts, and get_build_app shows how it ended and the url it went to. This makes changes live for real visitors — be sure the checkpoint is the one intended.

ui_get

ChatGPT
Fetch one Corte UI registry item with its full file contents (shadcn registry-item shape). Prefer npx shadcn@latest add @corte-ui/<name> when working in an app with the registry configured — it resolves dependencies too; use this when you need the source directly. Every component is available on every plan.

unpublish_content_document

ChatGPT
Take a document off the delivery API. The draft and its history stay; only the live copy goes away, so anything reading published content stops seeing it immediately. Confirm with the user before calling this. Refuses when another published document references this one — pass force:true only after telling the user which documents will be left pointing at nothing.

unschedule_growth_post

ChatGPT
Pull a scheduled post back before it goes out: it returns to draft, keeps its text, media and time, and will not publish until a person schedules or approves it again in Growth. Only a scheduled post can be pulled; once the send has started it is too late and the answer names the current state. Use it when the person wants to hold a post, or before editing one that is scheduled.

update_ad

ChatGPT
Approve or reject an ad, or replace its layered document. Approving publishes the image at a permanent URL and puts it in the ad set’s feed; un-approving takes it out. A new doc (an AdDoc) is re-rendered and re-checked.

update_brand

ChatGPT
Replace the project’s brand doc. doc is the whole BrandDoc (read get_brand first and resend it with your changes — this is a full replace, not a merge). Unknown keys are dropped; values are validated (≤ 48 color tokens, ≤ 24 type levels, short strings ≤ 200 chars).

update_build_app

ChatGPT
Rename a Build app and/or change its public address. slug is the subdomain visitors use (<slug>.corte.sh — lowercase letters, digits and hyphens); the live site moves to the new address on the next request and the old one stops serving. Use it when an app was created with a working title, or the user names the product. The url a deploy reports (get_build_app) reflects the current slug.

update_content_document

ChatGPT
Edit a document’s draft. draft holds only the fields you want to change — every other field keeps its current value, so a one-field edit is safe. To clear a field, pass it explicitly as null. A localized field takes a locale map {"en":"…","de":"…"}; locales you leave out keep their value, and a locale set to null is cleared. It merges with anyone editing the same document live, so there is no version to pass. The response reports valid and any issues; drafts save even when invalid, and publish is what refuses. Rich text (portableText) is an array of nodes: text as {"_type":"block","style":"normal"|"h2"|"h3"|"h4"|"blockquote","children":[{"_type":"span","text":"…","marks":[]}],"markDefs":[]} (list items add "listItem":"bullet"|"number"; marks are strong/em/code or a markDef key for a {"_type":"link","_key","href"}), and an inline image as {"_type":"image","storageId":"…"} — a storageId from upload_asset or the library, never a URL or asset reference. _keys are optional.

update_content_settings

ChatGPT
Change the project’s locales or translation settings. locales replaces the whole list (read it first and resend it with your change) — each entry is {code, title, fallback: code|null, required: boolean}; codes are BCP-47 like "en", "pt-BR". defaultLocale must be one of them. translation.brief is the tone/glossary brief every machine translation follows; translation.autoTranslateOnPublish fills lagging locales into the draft after each publish; translation.model is which model translates — "auto" (a model chosen to suit the target language) or one of the ids in get_content_settings.models. Removing a locale hides it; stored values stay until documents are next saved.

update_content_type

ChatGPT
Edit a content type, by id or by machine name (e.g. "post"; a name is looked up in projectId). baseVersion must equal its current latestVersion (optimistic lock — refetch and retry on conflict). Changing fields mints a new immutable schema version and goes live immediately; title/description alone do not. name cannot change.

update_growth_campaign

ChatGPT
Rename a campaign or change its description (null clears it). Its posts are untouched.

update_growth_post

ChatGPT
Change a post that is still a draft or awaiting review: new text (replaces the whole text), new media (replaces the whole set), a different suggested time, a different channel in the same project, or a campaign (null detaches it). Omitted fields stay as they are. The new body is checked against the target channel’s platform limits. A scheduled post cannot be edited from here — a person approved those exact words — so call unschedule_growth_post first, then edit, and the person schedules it again in Growth. Published, failed and declined posts are history and do not change.

update_project

ChatGPT
Rename a project, change its description, or set its picture. Owner only; a contributor is refused. Omitted fields are left alone, and an empty description clears it. The picture must be an image the caller can read (a storageId from list_assets or a generation). Returns the project as get_project does.

update_workflow

ChatGPT
Change a saved workflow: rename it, replace its graph, or both. Omitted fields are unchanged. A graph you send REPLACES the whole stored graph — read it first with get_workflow, then send the complete new graph (all nodes and edges, keeping the ids of nodes people already refer to in run inputs). The same checks as create_workflow apply. Needs write access: the creator, or any member of the shared project the workflow lives in.

upload_asset

ChatGPT
Copy an image, video or audio file from a public https URL into the user’s Corte library, in the given project. Corte downloads the file once, server-side: the URL must be publicly reachable over https (no sign-in, no private or local addresses) and serve an image/, video/ or audio/* content type; anything else is refused. Files are limited to 1 GB and the download to five minutes. The copy counts toward the project payer’s storage quota and is refused when that quota is full; it costs no credits. Returns the new asset’s storageId (which generate, run_application and run_workflow take as an input), its size in bytes, and a link to read it. Calling it twice with the same URL stores two copies.

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/corte"><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/corte)