account_get
ChatGPTRead the org: plan, capability flags, concurrent_agent_runs, project counts
actions_confirm
ChatGPTA 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
ChatGPTA 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
ChatGPTThe 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
ChatGPTThe 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
ChatGPTThe 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
ChatGPTCampaigns 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
ChatGPTCampaigns 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
ChatGPTCampaigns 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
ChatGPTThe 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
ChatGPTThe 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
ChatGPTThe 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
ChatGPTRequest cooperative cancel of a Job
jobs_get
ChatGPTRead the current state and result of this connection's draft job. Status reconciliation may cancel expired work and enqueue webhook deliveries.
jobs_input
ChatGPTAnswer a needs_input Job's questions and resume it
knowledge_read_history
ChatGPTRead 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
ChatGPTRecord 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
ChatGPTOne 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
ChatGPTOne 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
ChatGPTOne 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
ChatGPTCreate 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
ChatGPTRead one campaign (recipe-resumable: schema, template, people, settings)
sequences_set_step_delay
ChatGPTA 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 }
setup_link
ChatGPTWhen the member has to do something themselves, send the part of the app that does it instead of explaining the steps: 'integrations' to connect a calendar, CRM or other app; 'senders' to connect or fix a mailbox; 'campaigns' to see their campaigns, never to make one; 'campaign' with its campaignId for one campaign. The url is the link to send; done is false because they do the rest. setup_link({ page: 'integrations' | 'senders' | 'campaigns' | 'campaign'; campaignId?: string }): Promise<{ done: false; url: string; what: string }>
tasks_get
ChatGPTBuilding 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
ChatGPTBuilding 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
ChatGPTBuilding 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
ChatGPTBuilding 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
ChatGPTBuilding 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