MCP App Store
by KeenEthics
Origami icon

Origami MCP Server for ChatGPT

By AirSplash Inc.

Overview

Manage sales outreach in Origami: review campaign results, pause or resume campaigns, change follow-up timing, manage leads, redraft inbox replies, and track background work. Direct campaign edits cover pause/resume and follow-up delays. Edit campaign copy and targeting, and send inbox replies, in Origami. Gated actions require confirmation. Requires an administrator of an Origami primary organization with API access and renewed OAuth consent. Background tasks use your Origami account's credits.

How to connect

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

Tools

account_get

ChatGPT
Read the org: plan, capability flags, concurrent_agent_runs, project counts

actions_confirm

ChatGPT
A call that needs their OK does not run yet: it answers needsOk with its action id and question. Confirm only after the person explicitly approves that action, then repeat the exact original call to run it. If the person rejects the action, decline it. actions_confirm({ actionId: string }): Promise<{ ok: true; confirmed: string } | { ok: false; why: string }> // confirmed: what it lets through

actions_decline

ChatGPT
A call that needs their OK does not run yet: it answers needsOk with its action id and question. Confirm only after the person explicitly approves that action, then repeat the exact original call to run it. If the person rejects the action, decline it. actions_decline({ actionId: string }): Promise<{ ok: true } | { ok: false; why: string }>

brief_budget

ChatGPT
The morning brief's reads: yesterday's numbers beside the week before, what waits on them, and the daily limit. brief_budget(): Promise<BudgetView> type BudgetView = { dailyLimit: string | null; spentToday: string | null; balance: string | null; runwayDays: number | null; warning: string | null; limitedLastNight: boolean }

brief_last_night

ChatGPT
The morning brief's reads: yesterday's numbers beside the week before, what waits on them, and the daily limit. brief_last_night(): Promise<LastNight> type BriefFigures = { peopleReached: number; replies: number; positiveReplies: number } type LastNight = { day: string; yesterday: BriefFigures; weekAverage: BriefFigures; night: string | null; budgetLimited: boolean } // weekAverage: per day, the 7 days before

brief_waiting

ChatGPT
The morning brief's reads: yesterday's numbers beside the week before, what waits on them, and the daily limit. brief_waiting(): Promise<WaitingItem[]> type WaitingItem = | { kind: 'approvals'; messages: number; plays: { campaignId: string; name: string; waiting: number }[] } // approved in Autopilot | { kind: 'start' | 'agree'; campaignId: string; name: string; when: string } // starts on its own unless held in Autopilot | { kind: 'pause'; campaignId: string; name: string; when: string; about: string } // pauses on its own unless kept | { kind: 'todo'; title: string; detail: string | null } // done in the app

campaigns_list

ChatGPT
Campaigns the member runs themselves. Plays Autopilot runs are not listed here; Autopilot holds and resumes them. campaigns_list: at most 100, live ones first. campaigns_pause and campaigns_resume answer the people they touched; say that number. campaigns_resume only resumes a paused campaign, and waits for their OK. campaigns_list(): Promise<CampaignLine[]> type CampaignLine = { campaignId: string; name: string; status: string people: number // how many people are in the campaign, the same count as a play's sequenceCount: what "how many people" means and what a live campaign's card shows; a draft's card shows who Launch starts with activePeople: number // of those, the ones still being messaged or stopped by a pause: who a pause or resume touches autopilot: boolean }

campaigns_pause

ChatGPT
Campaigns the member runs themselves. Plays Autopilot runs are not listed here; Autopilot holds and resumes them. campaigns_list: at most 100, live ones first. campaigns_pause and campaigns_resume answer the people they touched; say that number. campaigns_resume only resumes a paused campaign, and waits for their OK. campaigns_pause({ campaignId: string }): Promise<CampaignActResult> type CampaignActResult = | { ok: true; name: string; people: number; already: boolean; heldBack: string[] } // already: nothing changed; heldBack: who could not resume, and why | { ok: false; why: string }

campaigns_resume

ChatGPT
Campaigns the member runs themselves. Plays Autopilot runs are not listed here; Autopilot holds and resumes them. campaigns_list: at most 100, live ones first. campaigns_pause and campaigns_resume answer the people they touched; say that number. campaigns_resume only resumes a paused campaign, and waits for their OK. campaigns_resume({ campaignId: string }): Promise<CampaignActResult> type CampaignActResult = | { ok: true; name: string; people: number; already: boolean; heldBack: string[] } // already: nothing changed; heldBack: who could not resume, and why | { ok: false; why: string }

drafts_fill

ChatGPT
The reply Origami drafted to a lead. ref: the draft's id, or the lead's sequenceId from people_find or the replies. body is exactly what would be sent. To change it, pass their words to drafts_regenerate, which rewrites it with the whole thread. A lead's reply with no draft (drafts_get is null) gets one from drafts_regenerate, with their words or none. A needs_input draft goes once they answer what is in missing: ask in plain words, pass their answers to fill by gap key. Over text fill does not keep an answer for later drafts. Cards are for texts: anywhere else a reply is sent or discarded from the Inbox, where they read it first. drafts_fill({ ref: string; answers: Record<string, string> }): Promise<{ ok: true; draft: DraftCard } | { ok: false; why: string }> // answers: gap key -> their answer type DraftCard = { draftId: string; sequenceId: string; channel: 'email' | 'linkedin' status: 'drafted' | 'needs_input' // needs_input: it cannot go until they answer what is in missing body: string missing: { key: string; question: string }[] // each gap they still have to answer problem: string | null // why it cannot go even with every gap answered reason: string | null }

drafts_get

ChatGPT
The reply Origami drafted to a lead. ref: the draft's id, or the lead's sequenceId from people_find or the replies. body is exactly what would be sent. To change it, pass their words to drafts_regenerate, which rewrites it with the whole thread. A lead's reply with no draft (drafts_get is null) gets one from drafts_regenerate, with their words or none. A needs_input draft goes once they answer what is in missing: ask in plain words, pass their answers to fill by gap key. Over text fill does not keep an answer for later drafts. Cards are for texts: anywhere else a reply is sent or discarded from the Inbox, where they read it first. drafts_get({ ref: string }): Promise<DraftCard | null> type DraftCard = { draftId: string; sequenceId: string; channel: 'email' | 'linkedin' status: 'drafted' | 'needs_input' // needs_input: it cannot go until they answer what is in missing body: string missing: { key: string; question: string }[] // each gap they still have to answer problem: string | null // why it cannot go even with every gap answered reason: string | null }

drafts_regenerate

ChatGPT
The reply Origami drafted to a lead. ref: the draft's id, or the lead's sequenceId from people_find or the replies. body is exactly what would be sent. To change it, pass their words to drafts_regenerate, which rewrites it with the whole thread. A lead's reply with no draft (drafts_get is null) gets one from drafts_regenerate, with their words or none. A needs_input draft goes once they answer what is in missing: ask in plain words, pass their answers to fill by gap key. Over text fill does not keep an answer for later drafts. Cards are for texts: anywhere else a reply is sent or discarded from the Inbox, where they read it first. drafts_regenerate({ ref: string; feedback?: string }): Promise<{ ok: true; draft: DraftCard } | { ok: false; why: string }> type DraftCard = { draftId: string; sequenceId: string; channel: 'email' | 'linkedin' status: 'drafted' | 'needs_input' // needs_input: it cannot go until they answer what is in missing body: string missing: { key: string; question: string }[] // each gap they still have to answer problem: string | null // why it cannot go even with every gap answered reason: string | null }

jobs_cancel

ChatGPT
Request cooperative cancel of a Job

jobs_get

ChatGPT
Read the current state and result of this connection's draft job. Status reconciliation may cancel expired work and enqueue webhook deliveries.

jobs_input

ChatGPT
Answer a needs_input Job's questions and resume it

knowledge_read_history

ChatGPT
Read the history of what the user has taught Autopilot: each memory with their own words, the day and the chat they said it in, how it was read, what it changed in the knowledge base, and what it did to each play. Call it when the user asks why something changed or what they have already told you, and answer from the memories it returns: each one with its day and what it changed, in their words. When the read fails or matches nothing, say so in the answer rather than answering from the current rules alone, because the user is asking about what they said and when. Pass every filter null to read the organization's memories, newest first, at most 20. Give a filter only to narrow to one entry, play, chat or date range you know, since a filter given must match. Whole memories when few match, one line each when many do: narrow the filters to read those whole.

knowledge_update

ChatGPT
Record what you learned about the business: the changes to its company, ideal customer profiles, messaging rules, offers, hard rules, resources, and the memory of why, in one call. Everything in the call lands together or not at all. One call per lesson. A lesson that changes no entry is a memory on its own: leave changes empty. It is saved as your own finding. A correction they want kept in their own words is made in the app. On an account whose knowledge is documents, only offer and resource changes are saved here (a memory with no changes is too); a change to any other kind answers with the app page instead, and nothing is saved.

people_find

ChatGPT
One lead: look them up by name, email or company, stop every message to them, or take them out of their campaigns. people_remove with dryRun: true changes nothing and answers how many it would take out. A real remove waits for their OK. people_stop is immediate. Say the number of people either touches. people_find({ query: string }): Promise<PersonLine[]> type PersonLine = { sequenceId: string; campaignId: string; campaign: string; name: string | null; email: string | null; company: string | null; status: string }

people_remove

ChatGPT
One lead: look them up by name, email or company, stop every message to them, or take them out of their campaigns. people_remove with dryRun: true changes nothing and answers how many it would take out. A real remove waits for their OK. people_stop is immediate. Say the number of people either touches. people_remove({ sequenceIds: string[]; dryRun?: boolean }): Promise<PeopleRemoveResult> type PeopleRemoveResult = { ok: true; dryRun: boolean; people: number; alreadyRemoved: number; notFound: number } | { ok: false; why: string }

people_stop

ChatGPT
One lead: look them up by name, email or company, stop every message to them, or take them out of their campaigns. people_remove with dryRun: true changes nothing and answers how many it would take out. A real remove waits for their OK. people_stop is immediate. Say the number of people either touches. people_stop({ sequenceId: string }): Promise<{ ok: true; name: string; stopped: boolean } | { ok: false; why: string }>

send_campaigns_draft

ChatGPT
Create a saved email or LinkedIn campaign draft from a brief using the Origami agent. Returns an asynchronous draft job; does not launch outreach.

send_campaigns_get

ChatGPT
Read one campaign (recipe-resumable: schema, template, people, settings)

sequences_set_step_delay

ChatGPT
A campaign's steps. step counts from 1, so the first follow-up is 2; days is the wait before that step, 1 to 30. variant: its name or key; any value when the campaign has one. people: who the new wait reaches; say it. kept: people whose next message was already scheduled; they keep the old time, so say that too when it is above 0. already: the step already waited that long and nothing changed; say so. It waits for their OK, except in the app chat, where it runs. sequences_set_step_delay({ campaignId: string; variant: string; step: number; days: number }): Promise<StepDelayResult> type StepDelayResult = { ok: true; campaign: string; variant: string; step: number; days: number; was: number; people: number; kept: number; already: boolean } | { ok: false; why: string }

tasks_get

ChatGPT
Building and long or independent work, run in the background by the universal agent (the full Origami agent, the one in the app) in its own chat. It reports progress, a question it needs answered, and its result. Start one when the work takes many steps or minutes, and answer directly when one read or one change does it, because a task's first report takes minutes. A new campaign is a 'campaign_build' task; whether to ask first is the <acting> rule. brief is the whole job in your words. The task sees their latest texts verbatim and nothing else of this conversation, so the brief says who or what it is for, the limits they set, what done looks like, and what to leave for them to approve. Started from Claude or ChatGPT, it sees no texts, only the brief. kind 'campaign_build' builds a campaign the way Autopilot does: its id is the campaign's, and tasks_list/tasks_get/tasks_send/tasks_stop do not reach it. 'subchat' (the default) is any other work. credits caps its spend over all its turns (default 100, 250 for a campaign build, at most 2000); above 250 it waits for their OK. At most 3 run at once, campaign builds included. A waiting_on_you task stopped on its question: when you already hold the answer, send it yourself; otherwise ask them and send theirs. A change of plan goes in full through tasks_send, so the task carries on the same work and keeps what it found. A stopped task reports nothing more. tasks_get({ id: string }): Promise<(Task & { recent: string[] }) | null> // recent: the last things it said, newest first type TaskKind = 'subchat' | 'campaign_build' type Task = { id: string; kind: TaskKind; name: string; brief: string status: 'running' | 'waiting_on_you' | 'expired' | 'done' | 'failed' | 'stopped' // waiting_on_you: its turn ended on something it needs; expired: that went a day unanswered, and send still resumes it; stopped: someone stopped it, and it reports nothing progress: string | null // while running: where it is, in its words or the step it is on question: string | null // while waiting_on_you: what it needs before it can go further creditsUsed: number | null; startedAt: string; endedAt: string | null result?: { summary: string; facts: { label: string; value: string }[]; needs?: string; link?: string; differs?: string } // what its newest turn ended with; differs: what it did differently from their ask, or a default that changes what happens next }

tasks_list

ChatGPT
Building and long or independent work, run in the background by the universal agent (the full Origami agent, the one in the app) in its own chat. It reports progress, a question it needs answered, and its result. Start one when the work takes many steps or minutes, and answer directly when one read or one change does it, because a task's first report takes minutes. A new campaign is a 'campaign_build' task; whether to ask first is the <acting> rule. brief is the whole job in your words. The task sees their latest texts verbatim and nothing else of this conversation, so the brief says who or what it is for, the limits they set, what done looks like, and what to leave for them to approve. Started from Claude or ChatGPT, it sees no texts, only the brief. kind 'campaign_build' builds a campaign the way Autopilot does: its id is the campaign's, and tasks_list/tasks_get/tasks_send/tasks_stop do not reach it. 'subchat' (the default) is any other work. credits caps its spend over all its turns (default 100, 250 for a campaign build, at most 2000); above 250 it waits for their OK. At most 3 run at once, campaign builds included. A waiting_on_you task stopped on its question: when you already hold the answer, send it yourself; otherwise ask them and send theirs. A change of plan goes in full through tasks_send, so the task carries on the same work and keeps what it found. A stopped task reports nothing more. tasks_list(): Promise<Task[]> // the last week's, newest first type TaskKind = 'subchat' | 'campaign_build' type Task = { id: string; kind: TaskKind; name: string; brief: string status: 'running' | 'waiting_on_you' | 'expired' | 'done' | 'failed' | 'stopped' // waiting_on_you: its turn ended on something it needs; expired: that went a day unanswered, and send still resumes it; stopped: someone stopped it, and it reports nothing progress: string | null // while running: where it is, in its words or the step it is on question: string | null // while waiting_on_you: what it needs before it can go further creditsUsed: number | null; startedAt: string; endedAt: string | null result?: { summary: string; facts: { label: string; value: string }[]; needs?: string; link?: string; differs?: string } // what its newest turn ended with; differs: what it did differently from their ask, or a default that changes what happens next }

tasks_send

ChatGPT
Building and long or independent work, run in the background by the universal agent (the full Origami agent, the one in the app) in its own chat. It reports progress, a question it needs answered, and its result. Start one when the work takes many steps or minutes, and answer directly when one read or one change does it, because a task's first report takes minutes. A new campaign is a 'campaign_build' task; whether to ask first is the <acting> rule. brief is the whole job in your words. The task sees their latest texts verbatim and nothing else of this conversation, so the brief says who or what it is for, the limits they set, what done looks like, and what to leave for them to approve. Started from Claude or ChatGPT, it sees no texts, only the brief. kind 'campaign_build' builds a campaign the way Autopilot does: its id is the campaign's, and tasks_list/tasks_get/tasks_send/tasks_stop do not reach it. 'subchat' (the default) is any other work. credits caps its spend over all its turns (default 100, 250 for a campaign build, at most 2000); above 250 it waits for their OK. At most 3 run at once, campaign builds included. A waiting_on_you task stopped on its question: when you already hold the answer, send it yourself; otherwise ask them and send theirs. A change of plan goes in full through tasks_send, so the task carries on the same work and keeps what it found. A stopped task reports nothing more. tasks_send({ id: string; words: string }): Promise<{ queued: true }> // an answer to its question or a change of plan; it takes another turn once its current one ends

tasks_start

ChatGPT
Building and long or independent work, run in the background by the universal agent (the full Origami agent, the one in the app) in its own chat. It reports progress, a question it needs answered, and its result. Start one when the work takes many steps or minutes, and answer directly when one read or one change does it, because a task's first report takes minutes. A new campaign is a 'campaign_build' task; whether to ask first is the <acting> rule. brief is the whole job in your words. The task sees their latest texts verbatim and nothing else of this conversation, so the brief says who or what it is for, the limits they set, what done looks like, and what to leave for them to approve. Started from Claude or ChatGPT, it sees no texts, only the brief. kind 'campaign_build' builds a campaign the way Autopilot does: its id is the campaign's, and tasks_list/tasks_get/tasks_send/tasks_stop do not reach it. 'subchat' (the default) is any other work. credits caps its spend over all its turns (default 100, 250 for a campaign build, at most 2000); above 250 it waits for their OK. At most 3 run at once, campaign builds included. A waiting_on_you task stopped on its question: when you already hold the answer, send it yourself; otherwise ask them and send theirs. A change of plan goes in full through tasks_send, so the task carries on the same work and keeps what it found. A stopped task reports nothing more. tasks_start({ brief: string; kind?: TaskKind; name?: string; credits?: number; from?: string }): Promise<Task> // name: what its report calls it; the brief's opening words by default. from: with 'campaign_build', the id of the campaign it rebuilds after Change it, so their first ask carries over type TaskKind = 'subchat' | 'campaign_build' type Task = { id: string; kind: TaskKind; name: string; brief: string status: 'running' | 'waiting_on_you' | 'expired' | 'done' | 'failed' | 'stopped' // waiting_on_you: its turn ended on something it needs; expired: that went a day unanswered, and send still resumes it; stopped: someone stopped it, and it reports nothing progress: string | null // while running: where it is, in its words or the step it is on question: string | null // while waiting_on_you: what it needs before it can go further creditsUsed: number | null; startedAt: string; endedAt: string | null result?: { summary: string; facts: { label: string; value: string }[]; needs?: string; link?: string; differs?: string } // what its newest turn ended with; differs: what it did differently from their ask, or a default that changes what happens next }

tasks_stop

ChatGPT
Building and long or independent work, run in the background by the universal agent (the full Origami agent, the one in the app) in its own chat. It reports progress, a question it needs answered, and its result. Start one when the work takes many steps or minutes, and answer directly when one read or one change does it, because a task's first report takes minutes. A new campaign is a 'campaign_build' task; whether to ask first is the <acting> rule. brief is the whole job in your words. The task sees their latest texts verbatim and nothing else of this conversation, so the brief says who or what it is for, the limits they set, what done looks like, and what to leave for them to approve. Started from Claude or ChatGPT, it sees no texts, only the brief. kind 'campaign_build' builds a campaign the way Autopilot does: its id is the campaign's, and tasks_list/tasks_get/tasks_send/tasks_stop do not reach it. 'subchat' (the default) is any other work. credits caps its spend over all its turns (default 100, 250 for a campaign build, at most 2000); above 250 it waits for their OK. At most 3 run at once, campaign builds included. A waiting_on_you task stopped on its question: when you already hold the answer, send it yourself; otherwise ask them and send theirs. A change of plan goes in full through tasks_send, so the task carries on the same work and keeps what it found. A stopped task reports nothing more. tasks_stop({ id: string }): Promise<{ stopped: boolean }> // false when nothing was running

Capabilities

Writes

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