> ## Documentation Index
> Fetch the complete documentation index at: https://composio-preview.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Devin MCP

> AI-powered access to GitHub repository documentation and codebase analysis, including private repositories, via Devin.

![Devin MCP logo](https://mintcdn.com/composio-preview/VNLruGH5mLZqXdPH/images/toolkits/devin_mcp.svg?fit=max\&auto=format\&n=VNLruGH5mLZqXdPH\&q=85\&s=a50d94bad6de71d9c5eab016cc71aeae)

* **Category:** model context protocol
* **Auth:** API\_KEY
* **Composio-managed OAuth available?** N/A
* **Tools:** 23
* **Triggers:** 0
* **Slug:** `DEVIN_MCP`
* **Version:** 20261030\_00

## Tools

> [accordion] Ask wiki question
>
> **Slug:** `DEVIN_MCP_ASK_WIKI_QUESTION`
>
> Ask any question about a GitHub repository's codebase and get an AI-powered answer grounded in its DeepWiki.
>
> #### Input Parameters
>
> **question** `string` *required*
>
> The question to ask about the repository.
>
> **repoName** `string` *required*
>
> GitHub repository or list of repositories (max 10) in owner/repo format.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin automation manage
>
> **Slug:** `DEVIN_MCP_DEVIN_AUTOMATION_MANAGE`
>
> Manage Devin automations.
>
> Automations run Devin in response to events (GitHub activity, Slack messages, Linear updates, schedules, incoming webhooks). Each automation has triggers (which events fire it, with optional conditions and replies) and actions (what to do, e.g. start a session with a prompt). Single-automation results include the webapp URL.
>
> Call action="schemas" first when you build a new automation. It returns every supported trigger event type with its condition fields and replies, the RRULE and Slack rules, the action shapes, the config groups, and the validation constraints. Use action="validate\_create" or action="validate\_update" for a dry run that needs no approval.
>
> On create, follow "schemas" for session\_settings.net\_policy: when it reports a Git Manager starting policy, set it plus only the required hosts, even for tasks that need no external services; when a security profile governs the network, omit net\_policy so sessions inherit the profile's allowlist, and pick the tools.mcp\_servers the task needs from the servers the profile allows. Use null only for explicitly requested unrestricted access. Omit session\_settings for existing-session reminders without auto\_create.
>
> On "update", omitted top-level params stay unchanged. Whether a passed config group merges or replaces is per-organization: action="schemas" reports it under "Update semantics". When in doubt, fetch with "get" and include every field you want to keep.
>
> #### Input Parameters
>
> **name** `string`
>
> Human-readable name for the automation (1-500 characters). Required for 'create' and 'validate\_create'.
>
> **after** `string`
>
> Opaque cursor for 'list'/'preflight\_events' pagination (from a previous response's end\_cursor).
>
> **first** `string`
>
> Page size for 'list' (default 100) and 'preflight\_events' (default 20) pagination; max 200.
>
> **tools** `string`
>
> Tool grants for the sessions the automation spawns (slack\_dm\_scope goes inside this group, never as a top-level argument).
>
> **action** `string ("list" | "get" | "schemas" | "templates" | "create" | "validate_create" | "update" | "validate_update" | "delete" | "run" | "preflight_get" | "preflight_samples" | "preflight_events" | "preflight_event" | "preflight_test" | "preflight_run")` *required*
>
> 'templates' lists the built-in templates whose template\_id 'create' accepts. 'run' fires an enabled automation now and bypasses its trigger conditions. 'validate\_create' and 'validate\_update' dry-run the payload without approval. Preflight actions (only when 'schemas' reports it available): 'preflight\_get' (saved script and settings), 'preflight\_samples' (canned sample events to test against before any real event exists; with sample\_event\_type, that sample's \$EVENT\_FILE), 'preflight\_events' (an automation's recent matched events), 'preflight\_event' (one event's \$EVENT\_FILE), 'preflight\_test' (run a script, saved or not, on a real VM against a sample or a recent event; starts no actions; without automation\_id it is a draft run for an automation that does not exist yet), 'preflight\_run' (poll a test run's outcome and logs). Save the script through the 'preflight' parameter of create/update.
>
> **limits** `string`
>
> Resource limits for the automation and the sessions it spawns.
>
> **prompt** `string`
>
> For 'run' only: free-text stand-in for the triggering event, included in the event payload as additional context (max 10000 chars). Mutually exclusive with event\_data.
>
> **run\_as** `string`
>
> Identity the triggered sessions run under. REQUIRED for 'create', no default. Choose it together with tools.mcp\_servers. On 'update', omitted means unchanged.
>
> **run\_id** `string`
>
> For 'preflight\_run': the run\_id returned by 'preflight\_test'.
>
> **search** `string`
>
> Filter 'list' results by name substring.
>
> **actions** `string`
>
> What the automation does. Required for 'create'. Replaces all existing actions on 'update'. On a draft 'preflight\_test' (no automation\_id) pass the actions you will create with, so the draft applies the same default network policy as 'create'. Most automations use one start\_session action. Code scans use start\_code\_scan or scan\_new\_commits instead. Long prompts render as BEGIN/END PROMPT \<label> blocks: extract only the text between those two lines into a local file, edit it, and update with the full actions array and 'prompt': 'file:///absolute/path' (Devin's client resolves file URIs; other MCP clients must pass the text inline). Never retype a long prompt.
>
> **enabled** `string`
>
> Enable or disable the automation on 'create'/'update'; on 'list', filter to automations in that enabled state.
>
> **metadata** `string`
>
> Org-visible string key/value labels (max 16 pairs; keys \<= 32 chars, values \<= 128). Update behavior follows the org's update semantics from action="schemas". On 'list', filters to automations whose metadata matches every given pair (null values are invalid there).
>
> **triggers** `string`
>
> Events that dispatch the automation. Required for 'create'. Replaces all existing triggers on 'update'. Schedule triggers use an RFC 5545 RRULE condition with the 'recurrence' operator, e.g. \{'event\_type': 'schedule:recurring', 'conditions': \{'any': \[\{'all': \[\{'field': 'rrule', 'operator': 'recurrence', 'value': 'DTSTART;TZID=America/Los\_Angeles:19700101T000000\nRRULE:FREQ=DAILY;BYHOUR=6;BYMINUTE=0'}]}]}}. Read the full RRULE rules and examples from action='schemas'.
>
> **preflight** `string`
>
> For 'create'/'update' and their validate\_ dry-runs: the Preflight check, a script that runs before the actions and decides per trigger event whether to proceed, skip, or fan out. For 'preflight\_test': the script to run (saved or not). Pass the source as 'file:///absolute/path'. On update the whole group replaces the stored one; omitted keeps it. Preflight actions: 'preflight\_get' (saved script), 'preflight\_events' (recent matched trigger events), 'preflight\_event' (one event's full \$EVENT\_FILE document), 'preflight\_test' (run a script against a recent event on a real VM; starts no actions), 'preflight\_run' (poll a test run's outcome and logs). Available only when action='schemas' reports it.
>
> **creator\_id** `string`
>
> Filter 'list' results to automations created by this user id.
>
> **event\_data** `string`
>
> For 'run' only: structured stand-in for the event data the real source would have sent. Mutually exclusive with prompt.
>
> **event\_type** `string`
>
> Filter 'list' results to automations with a trigger of this event type, e.g. 'slack:message'.
>
> **agent\_types** `string`
>
> Filter 'list' results by agent type; multiple values match automations containing at least one action of any given type (OR). Values: 'new\_session' (start\_session), 'long\_running' (message\_session), 'triage\_session' (auto-triage), 'auto\_triage' (legacy monitor\_session), 'code\_scan' (start\_code\_scan / scan\_new\_commits), 'remediate\_finding', 'incident\_session'.
>
> **concurrency** `string`
>
> Caps on simultaneous runs and the queue of events waiting to run.
>
> **template\_id** `string`
>
> Create-only provenance marker from the automation templates endpoint.
>
> **automation\_id** `string`
>
> The automation ID. Required for 'get', 'update', 'validate\_update', 'delete', 'run', 'preflight\_get', 'preflight\_events', and 'preflight\_event'. Optional for 'preflight\_test'/'preflight\_run': omit it to test a script for an automation that does not exist yet (a draft run against a sample event), then pass the same 'preflight' group to 'create'.
>
> **notifications** `string`
>
> Email/Slack pings about the automation's dispatch outcomes.
>
> **queued\_event\_id** `string`
>
> For 'preflight\_event' (required) and 'preflight\_test' (optional; default = the most recent matched event that is not a manual run): a queued\_event\_id from 'preflight\_events'. Mutually exclusive with sample\_event\_type.
>
> **security\_profile** `string`
>
> Security-profile binding: \{'profile\_id': '...'} pins that profile, \{'profile\_id': null} records an explicit opt-out, omitted inherits the org/enterprise default. Writing it requires the security-profile management permission and is rejected from a Devin session: there, omit it and tell the user to pick the profile in the automation's editor in the webapp and, when that profile has a network policy, to turn off the automation's Network policy there so sessions use the profile's allowlist. An opt-out cannot escape a mandatory profile. Reads return \{'selection': 'inherit'|'none'|'profile', 'profile\_id', 'warnings': \[...]}. Warnings are non-blocking configuration conflicts; show them to the user.
>
> **session\_settings** `string`
>
> Settings applied to every session the automation spawns.
>
> **sample\_event\_type** `string`
>
> For 'preflight\_samples' (optional: show that sample's full \$EVENT\_FILE document) and 'preflight\_test' (test against the canned sample for this trigger event type, e.g. 'github:pull\_request'; required when automation\_id is omitted). Mutually exclusive with queued\_event\_id.
>
> **sample\_webhook\_body** `string`
>
> For 'preflight\_test' with sample\_event\_type 'webhook:incoming' only: the JSON body the user's system will POST to the webhook, used in place of the canned body (webhook payloads are user-defined; every other source's shape is fixed and the canned sample is authoritative). Ask the user for a real example. At most 64KB.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin billing tag manage
>
> **Slug:** `DEVIN_MCP_DEVIN_BILLING_TAG_MANAGE`
>
> Manage Devin billing tags (groupings of Devin sessions for usage tracking) with a single action-based tool: list/get/create tags, assign sessions one at a time or in bulk (up to 500 per call, sent in sequential batches of 100), and read the billing tags of up to 100 sessions at once ('get\_session\_tags'). Only available in private mode (via devin.ai endpoints).
>
> #### Input Parameters
>
> **name** `string`
>
> Billing tag display name. Required for 'create'.
>
> **after** `string`
>
> Opaque cursor for 'list' pagination (from a previous response's end\_cursor).
>
> **first** `string`
>
> Page size for 'list' pagination (default 100, max 200).
>
> **action** `string ("list" | "get" | "create" | "assign_session" | "assign_sessions" | "get_session_tags")` *required*
>
> Operation to perform: 'list', 'get', 'create', 'assign\_session', 'assign\_sessions', or 'get\_session\_tags'.
>
> **devin\_id** `string`
>
> ID of the Devin session to assign. Required for 'assign\_session'. Assigning replaces the session's current billing tag.
>
> **assignments** `string`
>
> Map of Devin session ID -> billing tag ID (1-500 entries). Required for 'assign\_sessions'. A null value marks the session as miscellaneous (no billing tag). Assignments are sent to the API in sequential batches of 100. Partial success: sessions or tags not found in the organization, or sessions you can't write, are reported per entry.
>
> **description** `string`
>
> Free-form description of what work the tag covers. Optional for 'create'.
>
> **session\_ids** `string`
>
> Session ids to look up billing tags for, at most 100. Required for 'get\_session\_tags'. Both 'devin-abc123' and 'abc123' are accepted. Each session comes back with its billing tag, as having no billing tag when it was categorized as Miscellaneous or its tag was deleted, as never categorized, or as not found.
>
> **billing\_tag\_id** `string`
>
> Billing tag id. Required for 'get'. For 'assign\_session', the tag to assign; omit it to mark the session as miscellaneous (no tag).
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin blueprint test
>
> **Slug:** `DEVIN_MCP_DEVIN_BLUEPRINT_TEST`
>
> Test a candidate blueprint YAML in an authoring VM: start → run initialize → fix → run initialize again (clean VM) → run maintenance → then persist with update\_environment\_config.
>
> #### Input Parameters
>
> **name** `string`
>
> Knowledge command name, when target is knowledge.
>
> **yaml** `string`
>
> Candidate blueprint YAML for a run.
>
> **after** `integer`
>
> Log cursor for get.
>
> **scope** `string`
>
> Optional repository scope for the run working directory.
>
> **action** `string ("start" | "run" | "get" | "cancel" | "close")` *required*
>
> Operation: start, run, get, cancel, or close.
>
> **run\_id** `string`
>
> Run ID for get and cancel.
>
> **target** `string`
>
> Blueprint target: initialize, maintenance, or knowledge.
>
> **platform** `string`
>
> Authoring VM platform label.
>
> **platforms** `string`
>
> Platform labels matching YAML "runs-on" values; use "default" for the default platform. Defaults to \[platform].
>
> **repo\_name** `string`
>
> Repository name used to create or set the session working directory.
>
> **author\_session\_id** `string`
>
> Author session ID for run, get, cancel, and close.
>
> **wait\_timeout\_seconds** `integer`
>
> Maximum time to wait for a run. Capped below the 15-minute approval window; use `get` to keep following a longer run.
>
> **poll\_interval\_seconds** `integer`
>
> Seconds between run polls; capped so keepalives keep flowing.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin code scan manage
>
> **Slug:** `DEVIN_MCP_DEVIN_CODE_SCAN_MANAGE`
>
> Manage Devin code scans (sometimes referred to as "security scans" or "Devin Security Swarm"). Targets the authenticated organization and requires the org code scan view permission for read actions or use permission for creation and remediation. Code scanning must be enabled for the org.
>
> The "create\_profile" action creates an org-owned scan profile that mutates the organization's scan configuration. The profile's mode is fixed at creation; the guidance fields define the scan's objective for non-security scan types. The "update\_profile" action edits an existing org-owned profile: only the fields you set are changed; omitted fields are left untouched. Pass an empty string to clear a guidance field. For a 'security' profile the edit is not applied directly: it is posted to this session as an approval card showing the current and proposed profile, and takes effect only once the user approves it there. When the result says the change is awaiting approval, tell the user to review the card and never claim the profile was updated; a newer suggestion for the same profile supersedes the pending one.
>
> A profile is a reusable configuration that codifies a team's scanning strategy. For 'security' scans it is user-facing (the Security page shows profiles by name): list them so the user can pick one, create a new one, or run with the defaults. For every other scan type it is an implementation detail: do not say "profile" to the user, list profiles for them, or ask them to pick or name one. Infer what they want from the conversation and submitted setup form, then create or reuse a profile yourself to match. Let the form explain its settings instead of repeating them in prose. When building the configuration:
>
> * Establish the scan type FIRST: call "list\_scan\_types" to see which types the org may use. The full set is 'security', 'performance', 'db-queries', 'test-coverage', 'dead-code', 'code-quality', 'cleanup' (behavior-preserving cleanup of messy, redundant, over-built code), 'telemetry', 'accessibility', 'compliance', 'migration-docs', and 'general' (no fixed domain — the profile defines the objective), but orgs without general scans enabled can only use 'security'; never use a type that is not listed. Infer the type from what the user asked for instead of presenting the types as a menu: a standard type only when they asked for its whole domain (its name or an obvious synonym); anything narrower, merely adjacent, or uncovered ("camelCase variable names", "memory leaks") is a 'general' scan aimed at exactly that — never round a request to the nearest standard type. State the choice in a clause so they can correct it, and only ask when the request is genuinely ambiguous between two standard types. A profile only appears in scan creation for its own type, so always set scan\_type explicitly to that type; a profile created with the wrong type will not show up where the user expects it.
> * Infer focus and exclusions from the conversation and optional form guidance: problems or areas to focus on, parts of the codebase to skip (e.g. generated code, vendored deps, test fixtures), and anything that is always critical or never worth reporting. Map the answers onto fields yourself — threat\_model\_guidance (what to look for; the UI calls this the "scan model"), include/exclude globs (which files are scanned), triage\_guidance (dedup/priority policy) — and never ask the user to fill in fields or enumerate them. Blank guidance uses defaults while preserving earlier instructions; do not ask again. Only set investigation, validation, report, or remediation guidance if the user volunteered that detail (validation guidance says how to build and run the code to confirm findings; without it that phase is skipped).
> * Default non-security discover scans to a Slack DM summary to the requester when the scan finishes. Do not ask about communication or change it unless the user explicitly requests an override; store it as communication\_guidance. Profiles are shared across the org: when reusing one that has no communication\_guidance, fill it in with "update\_profile" (create an org-owned copy for an account-owned profile that cannot be edited); if its guidance differs from what the user wants, create a new profile rather than overwriting it. Security and ingest scans do not run this phase.
> * Reuse an existing profile ("list\_profiles" with scan\_type set to the chosen type, then "get\_profile") only when its description clearly covers what the user asked for; otherwise create a new one. A profile for a different scan type is never an option for this scan — do not propose, reuse, or retype one. If you reuse one, say so in the user's terms ("your team has scanned for this before — I'll reuse that setup").
> * If the user's findings already come from their own scanner or security process, create an ingest-mode profile (mode='ingest') instead of a discover profile: ingestion\_source\_guidance is then required in practice and must be concrete (where findings live, how to authenticate — reference credentials by org secret name, never inline a token), with optional post\_ingestion\_guidance for triage policy. Ingest profiles have no scope globs or scan model.
>
> Before setting up a scan, invoke the creating-code-scans skill. State the inferred objective and notifications concisely, then use code\_scan\_setup\_form with real git\_list\_repos choices and optional guidance; only security scans offer an effort choice (Deep by default), every other type runs at "normal". No interactive-mode question; use false. NEVER call "create\_scan" until the user has explicitly approved a summary of the exact scan you are about to create through the submitted form and stated context, or a text confirmation when the form is unavailable or read-only. Submission of the pending form is approval; do not ask for another confirmation of unchanged settings. Dismissal is not approval. Map form effort "lite" (Normal) to "normal" for this tool, and "deep" to "deep". Permission prompts and access checks still apply. A request to run a scan is a request to set one up, not approval to launch it, and until they confirm you are setting a scan up — never tell them you are launching or starting one. After a successful "create\_scan", give the user the returned scan URL for security scans, or the orchestrating session URL for all non-security scans (never their scan page). If the session is not ready yet, use get\_session with the returned scan\_id; do not create the scan again. The scan runs in its own session.
>
> Scans are typed (e.g. 'security', 'general'). A non-security scan's objective is defined by its profile, so every non-security scan type requires a profile\_id. When a profile is given, the scan's type comes from the profile; an explicit scan\_type must match it.
>
> Scans are re-runnable: once a scan has completed, "scan\_new\_commits" scans only the commits landed since, on the same scan and with the same setup, so its findings join the existing ones. Prefer it over a new scan whenever the user wants an existing scan refreshed. It needs no confirmation flow beyond the user asking for it, and returns 409 while the scan is still running or has never completed.
>
> A scan's profile is not frozen: "update\_scan" changes the profile applied to its future incremental runs, whether those runs are triggered manually or by a scan\_new\_commits automation. Completed runs and their findings are unaffected; it returns 409 while a run is active. Use it when the user wants an existing scan pointed at a revised profile — do not create a new scan for that. Effort is fixed at creation. Scans carry no MCP-server grants of their own: for an automation-launched scan those come from the automation's tools.mcp\_servers (devin\_automation\_manage), and a start\_code\_scan automation's code\_scan\_effort/profile\_id are likewise edited on the automation.
>
> The "remediate\_finding" and "remediate\_findings" actions launch a Devin session that modifies code and attempts to open pull requests. Use them only when the user has explicitly requested remediation of those findings. Always fix findings through these actions, never by changing code or opening a pull request from your own session. For more than one finding use "remediate\_findings" once (it groups related findings into as few pull requests as makes sense) rather than "remediate\_finding" per finding.
>
> #### Input Parameters
>
> **host** `string`
>
> Git host of the repository/repositories ('create\_scan' only).
>
> **mode** `string`
>
> Profile mode: 'discover' (default) or 'ingest' ('create\_profile' only; the mode is fixed at creation).
>
> **after** `string`
>
> Opaque cursor for list pagination (from a previous response's end\_cursor).
>
> **first** `string`
>
> Page size for list actions (default 100, max 200).
>
> **repos** `string`
>
> Full names of the repositories to scan together as one scan ('create\_scan'; provide exactly one of repo\_name or repos). The first entry is the scan's primary repo. Use this whenever the user wants more than one repository covered.
>
> **action** `string ("list_scans" | "list_findings" | "list_scan_types" | "list_profiles" | "get_profile" | "create_profile" | "update_profile" | "create_scan" | "update_scan" | "scan_new_commits" | "get_session" | "remediate_finding" | "remediate_findings")` *required*
>
> The operation to perform: 'list\_scans', 'list\_findings', 'list\_scan\_types', 'list\_profiles', 'get\_profile', 'create\_profile', 'update\_profile', 'create\_scan', 'update\_scan', 'scan\_new\_commits', 'get\_session', 'remediate\_finding', or 'remediate\_findings'. 'list\_scan\_types' returns the scan types enabled for this org — only ever use those types (when general scans are disabled, only 'security'). Pick the type from the user's request yourself rather than presenting the types as a menu; use 'general' for anything no standard type covers. 'create\_scan' launches the scan: only call it after the user has explicitly confirmed the setup by submitting code\_scan\_setup\_form, or confirming a text summary when the form cannot be used. Preserve approved repositories, objective, effort, and notifications. 'scan\_new\_commits' re-runs an existing, completed scan against only the commits landed since it last ran — use it (not 'create\_scan') whenever the user wants an existing scan brought up to date, e.g. "scan for new commits" or "rescan"; findings accumulate on the same scan. 'update\_scan' changes the profile an existing scan applies to its future incremental runs (manual scan\_new\_commits and scan\_new\_commits automations alike) — use it (not a new scan) when the user wants an existing scan moved onto a different or revised profile. 'get\_session' retrieves the latest run's orchestrating session link for a scan.
>
> **effort** `string`
>
> Scan effort ('create\_scan' only): 'normal' (default) uses lower model reasoning effort and larger investigation batches — faster; 'deep' runs the full pipeline, tracing each finding further and validating findings one at a time — most thorough, slower. Only security scans offer the choice; every other scan type uses 'normal'. Explain the trade-off in terms of time and thoroughness only (never cost or usage).
>
> **status** `string`
>
> Filter findings to these statuses: 'open', 'dismissed', 'resolved' ('list\_findings' only).
>
> **scan\_id** `string`
>
> Filter findings to this scan ('list\_findings'), or the scan ID containing the finding(s) ('remediate\_finding', 'remediate\_findings'), or the scan to re-run ('scan\_new\_commits'), or the scan to reconfigure ('update\_scan'), or the scan whose orchestrating session to retrieve ('get\_session').
>
> **summary** `string`
>
> One-sentence, user-facing description of the proposed change, shown on the approval card when 'update\_profile' targets a 'security' profile.
>
> **severity** `string`
>
> Filter findings to these severities: 'critical', 'high', 'medium', 'low' ('list\_findings' only).
>
> **repo\_name** `string`
>
> Filter to this repository ('list\_scans' and 'list\_findings'), or the full repository name to scan ('create\_scan'; provide exactly one of repo\_name or repos).
>
> **scan\_type** `string`
>
> Type of scan, e.g. 'security' or 'general' ('create\_scan', 'create\_profile', 'list\_profiles'). For 'list\_profiles': only return profiles for this scan type — always pass the chosen type so profiles for other types are never shown or considered. For 'create\_scan': must match the chosen profile's scan type; defaults to the profile's type, or 'security' when neither a profile nor a type is given. Every non-security scan type requires a profile\_id — the profile defines the scan's objective. For 'create\_profile': the type of scan the profile configures (defaults to 'security'). For 'update\_profile': the new scan type of the profile.
>
> **finding\_id** `string`
>
> The finding ID. Required for 'remediate\_finding'.
>
> **profile\_id** `string`
>
> The profile ID. Required for 'get\_profile', 'update\_profile' and 'update\_scan' (the profile future incremental runs use; must match the scan's type and mode); optional for 'create\_scan'.
>
> **scan\_paths** `string`
>
> Repository-relative paths to restrict scans to ('create\_profile' and 'update\_profile'). Include globs do not widen an existing restriction; pass \[] with 'update\_profile' to lift it.
>
> **time\_after** `string`
>
> Unix seconds lower bound. Optional creation-time filter ('list\_scans' only).
>
> **description** `string`
>
> Description of the profile ('create\_profile' and 'update\_profile').
>
> **finding\_ids** `string`
>
> Findings of scan\_id to fix together ('remediate\_findings'; at least one). One session plans and groups them, then opens one pull request per group.
>
> **interactive** `string`
>
> Interactive mode ('create\_scan', security scans only): true pauses the scan once it has drafted its threat model and opens a session where the user reviews and adjusts it before investigation starts; false (default) runs end to end unattended. For security scans explain the difference, then ask. Never offer or set it for any other scan type — those always run unattended.
>
> **time\_before** `string`
>
> Unix seconds upper bound. Optional creation-time filter ('list\_scans' only).
>
> **profile\_name** `string`
>
> Name of the profile. Required for 'create\_profile'; optional new name for 'update\_profile'.
>
> **exclude\_globs** `string`
>
> Glob patterns of files to exclude from scans ('create\_profile' and 'update\_profile').
>
> **include\_globs** `string`
>
> Glob patterns of files to include in scans ('create\_profile' and 'update\_profile').
>
> **report\_guidance** `string`
>
> Guidance for the report phase ('create\_profile' and 'update\_profile').
>
> **triage\_guidance** `string`
>
> Guidance for the triage phase ('create\_profile' and 'update\_profile').
>
> **validation\_guidance** `string`
>
> Guidance for the validation phase ('create\_profile' and 'update\_profile').
>
> **remediation\_guidance** `string`
>
> Guidance for the remediation phase ('create\_profile' and 'update\_profile').
>
> **threat\_model\_guidance** `string`
>
> Guidance describing the threat model ('create\_profile' and 'update\_profile').
>
> **validation\_severities** `string`
>
> Finding severities runtime validation covers, from 'critical', 'high', 'medium', 'low' ('create\_profile' and 'update\_profile'; security profiles only). Omit for the default (critical, high, medium); pass \[] with 'update\_profile' to restore it.
>
> **communication\_guidance** `string`
>
> Guidance for the communication phase: what happens when the scan finishes, e.g. Slack the requester a summary, or ping the code owners of each finding with it and its fix ('create\_profile' and 'update\_profile'). Always ask the user about this for non-security discover profiles. Security and ingest scans do not run this phase.
>
> **investigation\_guidance** `string`
>
> Guidance for the investigation phase ('create\_profile' and 'update\_profile').
>
> **post\_ingestion\_guidance** `string`
>
> Guidance for the post-ingestion phase ('create\_profile' and 'update\_profile').
>
> **ingestion\_source\_guidance** `string`
>
> Guidance describing the ingestion source ('create\_profile' and 'update\_profile').
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin find setting
>
> **Slug:** `DEVIN_MCP_DEVIN_FIND_SETTING`
>
> Find a Devin webapp setting and get a deep-link URL to it. Use for "where do I change X?". The output includes everything needed to build the final URL.
>
> #### Input Parameters
>
> **query** `string`
>
> Feature keywords (e.g. "queue messages", "fast mode"). Omit for the full settings catalog.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin knowledge manage
>
> **Slug:** `DEVIN_MCP_DEVIN_KNOWLEDGE_MANAGE`
>
> Manage Devin knowledge notes and suggestions via a single action-based tool.
>
> #### Input Parameters
>
> **body** `string`
>
> Deprecated alias for `content`. Prefer `content`; this is accepted only for backward compatibility with older callers/skills.
>
> **name** `string`
>
> Note name — required for create and update (v3 PUT is full-replace).
>
> **after** `string`
>
> Opaque cursor for 'list' pagination (from a previous response's end\_cursor).
>
> **first** `string`
>
> Page size for 'list' pagination (default 100, max 200).
>
> **limit** `string`
>
> Page size for list\_suggestions (default 20, max 100).
>
> **query** `string`
>
> Search query for list\_suggestions — filters by trigger/content text.
>
> **action** `string ("list" | "get" | "create" | "update" | "delete" | "folders" | "list_suggestions" | "view_suggestion" | "dismiss_suggestions")` *required*
>
> Operation to perform. Notes: 'list', 'get', 'create', 'update', 'delete', 'folders' (returns the folder structure with per-folder note counts). Suggestions: 'list\_suggestions', 'view\_suggestion', 'dismiss\_suggestions'.
>
> **offset** `string`
>
> Pagination offset for list\_suggestions (default 0).
>
> **search** `string`
>
> Search query for 'list' — case-insensitive substring match across note name, trigger, and content. Useful for dedup and conflict detection.
>
> **status** `string`
>
> Filter suggestions by status (default 'pending'). Valid: 'pending', 'accepted', 'rejected'.
>
> **content** `string`
>
> Note content — required for create and update (v3 PUT is full-replace).
>
> **note\_id** `string`
>
> Note ID — required for get, update, delete.
>
> **trigger** `string`
>
> Trigger description — required for create and update (v3 PUT is full-replace).
>
> **event\_id** `string`
>
> Event ID of a knowledge suggestion — required for view\_suggestion.
>
> **event\_ids** `string`
>
> List of event IDs to dismiss — required for dismiss\_suggestions.
>
> **since\_days** `string`
>
> Only return suggestions from the last N days (list\_suggestions).
>
> **folder\_path** `string`
>
> Filter 'list' results to notes in a specific folder (e.g. 'Dana/SubFolder' or '/' for root notes only).
>
> **pinned\_repo** `string`
>
> Pin this note to a specific repo (owner/repo format). For create/update: sets the pinned repo. For list: filters results to notes pinned to this repo.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin list integrations
>
> **Slug:** `DEVIN_MCP_DEVIN_LIST_INTEGRATIONS`
>
> List native integrations and MCP servers for the organization, with status and settings/install URLs.
>
> Returns a JSON object with two arrays: "integrations" (native integrations like GitHub, Jira, Slack) and "mcp\_servers" (marketplace MCP servers). Each entry includes whether it's installed and a path-only URL to the settings/setup page (no host, works with custom enterprise domains). Pass `query` to look up a specific server by name — an empty "mcp\_servers" array then means it is not in the marketplace (install it as a custom server with devin\_mcp\_server\_manage instead).
>
> #### Input Parameters
>
> **query** `string`
>
> Case-insensitive substring matched against name, slug, and description. Use it whenever you are looking for one specific integration or MCP server (e.g. query='whimsical'); the unfiltered catalog is large.
>
> **filter** `string ("all" | "installed" | "not_installed")`
>
> Filter results — 'all' (default), 'installed', or 'not\_installed'.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin mcp server manage
>
> **Slug:** `DEVIN_MCP_DEVIN_MCP_SERVER_MANAGE`
>
> Manage MCP server installations for the organization: install (from the marketplace or custom), update, delete, enable, or disable. Marketplace installs use the one-call fast path. Before a custom install, use web research to confirm the official endpoint and authentication method. For an API key, use request\_secret and pass only auth\_header\_secret\_name. Never ask the user to paste a secret into normal session text. The pre-approval check rejects OAuth when automatic registration cannot complete. Install, update, and delete show the approval card unless the call is pre-approved, so do not send another approval request. Only available in private mode.
>
> #### Input Parameters
>
> **url** `string`
>
> Server URL. Required for HTTP/SSE transport on a custom 'install'. On a marketplace 'install', only to select a URL variant (e.g. a region): it must keep the scheme and host of one of the manifest's URLs; omit it for the default.
>
> **icon** `string`
>
> Icon URL for the approval card. Set automatically; do not set it.
>
> **name** `string`
>
> Display name. Required for a custom 'install'.
>
> **slug** `string`
>
> URL-safe identifier for the installation. Required for a custom 'install'.
>
> **action** `string ("install" | "resolve_install" | "update" | "delete" | "enable" | "disable")` *required*
>
> Operation to perform. 'resolve\_install' is read-only: it resolves a marketplace server or validates a custom server before the approval card.
>
> **command** `string`
>
> Command to run. Required for STDIO transport on a custom 'install'.
>
> **transport** `string`
>
> 'HTTP', 'SSE', or 'STDIO'. Required for a custom 'install'.
>
> **auth\_method** `string`
>
> 'none', 'auth\_header', or 'oauth'. Before a custom install, research the provider's official documentation and select a supported method. Never put a credential value in this tool call.
>
> **description** `string`
>
> Longer description. Optional.
>
> **oauth\_scope** `string`
>
> OAuth scope. Custom installs only.
>
> **oauth\_resource** `string`
>
> OAuth resource indicator. Custom installs only.
>
> **auth\_header\_key** `string`
>
> Header name for custom auth\_header installs. Defaults to Authorization.
>
> **installation\_id** `string`
>
> Installation id. Required for 'update', 'delete', 'enable', and 'disable'. Find it with devin\_list\_integrations.
>
> **oauth\_client\_id** `string`
>
> Pre-registered OAuth client ID for a custom install. Client IDs are identifiers, not secret values. If the provider also requires a client secret, configure that secret in Settings instead of putting it in session text.
>
> **short\_description** `string`
>
> One-line description. Required for a custom 'install'.
>
> **auth\_header\_format** `string`
>
> How to format auth\_header\_secret\_name: 'bearer' creates 'Bearer \$\{SECRET\_NAME}'; 'raw' creates '\$\{SECRET\_NAME}'. Defaults to 'bearer'.
>
> **installation\_scope** `string`
>
> Optional override: 'org' (Organization) shares one credential org-wide; 'user' (Personal) has each member connect their own account. Omit unless the user requests a scope; the marketplace default (or 'org') applies.
>
> **auth\_header\_secret\_name** `string`
>
> Protected Brain secret name for a custom auth\_header install. First use request\_secret and tell the user never to paste the value into normal session text. Pass only the name here; the credential value is never included in the install card. The name must start with MCP\_ to limit access to MCP-specific secrets. For an org installation, use an org-scoped saved secret. A temporary secret works only in the current session.
>
> **marketplace\_server\_slug** `string`
>
> For 'install': the marketplace server's slug or exact name (e.g. 'notion' or 'Notion'); no prior devin\_list\_integrations call is needed. Transport, command, and auth come from the marketplace manifest and cannot be overridden; url may only select a variant the manifest allows. Omit to install a custom server.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin oncall manage
>
> **Slug:** `DEVIN_MCP_DEVIN_ONCALL_MANAGE`
>
> Manage Devin Oncall. Oncall resources mirror automations (same triggers / tools / limits / session\_settings / session / run\_as / metadata groups and the same merge-patch update semantics) — only the action is implicit: a responder triages one Slack channel or the account's PagerDuty incidents (posting its findings as incident notes), an incident investigates one incident channel, a report summarizes responders/incidents on a schedule.
>
> Resources and actions:
>
> * responder: list, get, create, validate\_create, update, validate\_update, delete, issues (a responder's open issues, paged via first/after/order\_by).
> * incident\_settings: get, update, validate\_update (one settings object per org; PATCH).
> * incident: list (report\_id= returns that report's next-run period, candidates and period counts), get (Slack channel, parent session, report ids — the incident report is the 'incident-report.md' attachment on the parent session; fetch it with devin\_session\_interact get\_attachments), stop, resume.
> * report: list, get (config + live membership), create, validate\_create, update, validate\_update, delete, runs (GET history, or POST a new immutable run when incident\_ids is supplied), run (one run with its frozen sections and counts).
> * schemas (no resource): default\_net\_policy, the governing security profile (name, whether it governs the network, MCP servers it allows), default\_devin\_mode / available modes, default\_runbook, slack\_connected, pagerduty\_connection\_id (non-null iff PagerDuty responders can be created; pagerduty:\* trigger schemas are listed only then). ingest\_dashboard (no resource): queue an unattended run that turns a Datadog/New Relic dashboard into Oncall knowledge.
>
> Creating: call 'schemas' first when unsure about modes or the network policy. Defaults when omitted — run\_as organization (the system user), devin\_mode = best available (Ultra when the org has it), net\_policy = deployment Git Manager-only policy, or the governing security profile's allowlist when one governs the network, no runbook, Linear on, responder Slack grants following the watched channels, incident auto-join on. Recommend metadata.team (and service), tools.mcp\_servers only for telemetry servers the org has installed (and the profile allows, when it lists MCP servers), and Slack delivery for reports when a channel is known. Never invent Slack channel IDs. Use validate\_create/validate\_update to dry-run a payload. Creates are not idempotent: on ambiguous failure, list before retrying. Update is a merge-patch: omitted params keep their value; within a passed group (tools, limits, session\_settings, session, run\_as, metadata) a null key clears it; lists replace wholesale. Top-level params cannot be nulled through this tool — runbook, slack\_channel\_prefix, slack\_team\_id, response\_mode and incidents\_match take '' instead. Mutations (create/update/delete/stop/resume/ingest\_dashboard) require the user's approval. report runs POST is accepted server-side only from that report's schedule session.
>
> #### Input Parameters
>
> **name** `string`
>
> Display name for responder/report create (required) or update.
>
> **type** `string`
>
> 'ingest\_dashboard': dashboard source, 'datadog' (default) or 'newrelic'.
>
> **after** `string`
>
> Opaque cursor for list/issues/runs pagination (from a previous response).
>
> **first** `string`
>
> Page size for list/issues/runs (default 100, max 200).
>
> **tools** `string`
>
> Responder / incident\_settings tool grants for spawned sessions: mcp\_servers (only telemetry servers the org has installed — check devin\_list\_integrations), slack\_channels, linear\_enabled. Omit slack\_channels on responder create to use the default: watched channels for channel-scoped triggers, All public channels for channel-less triggers. Explicit permissions override the default; matching a message never adds its channel to Slack tool permissions. Update merges per member; lists replace wholesale.
>
> **action** `string ("list" | "get" | "create" | "validate_create" | "update" | "validate_update" | "delete" | "issues" | "stop" | "resume" | "runs" | "run" | "schemas" | "ingest_dashboard" | "report_context" | "responder_issues" | "report_stats" | "digest_runs" | "incident_candidates" | "submit_report_run")` *required*
>
> Operation to perform on 'resource': 'list', 'get', 'create', 'validate\_create', 'update', 'validate\_update', 'delete', 'issues' (responder), 'stop'/'resume' (incident), 'runs'/'run' (report). Without a resource: 'schemas' (defaults, available modes, Slack connectivity) or 'ingest\_dashboard'. The flat legacy names (report\_context, responder\_issues, ...) are aliases for older prompts; do not use them in new ones.
>
> **limits** `string`
>
> Responder limits: max\_acu\_limit per triage session and invocations rate (server default 150 per hour). Omit unless the user asks.
>
> **report** `string`
>
> Report 'runs' POST: the full report body in markdown.
>
> **run\_as** `string`
>
> Identity spawned sessions run as: \{'type': 'organization'} (default; the org system user, recommended so triage survives the creator leaving) or \{'type': 'creator'}.
>
> **run\_id** `string`
>
> Report run id for report 'run'.
>
> **enabled** `string`
>
> Responder: whether it triages new messages (default true). incident\_settings: whether the incident feature is on for the org.
>
> **runbook** `string`
>
> Responder investigation instructions. Omit by default — the server applies 'Investigate the root cause to the best of your abilities.' Only supply one when the user gives concrete investigation steps; pass '' on update to reset to the default.
>
> **session** `string`
>
> Responder / incident\_settings / report session tags (cost codes) spawned sessions bill to, validated as the run identity. Orgs that require session tags must supply exactly one allowed tag; otherwise omit.
>
> **summary** `string`
>
> Report 'runs' POST: at-most-2-sentence overview of the period vs the previous run.
>
> **team\_id** `string`
>
> Slack workspace (team) ID for the responder's channel; omit when the org has one workspace.
>
> **metadata** `string`
>
> Responder labels. Recommend \{'team': ...} always and \{'service': ...} when obvious from the channel/runbook; reports can select members by these tags (responder\_tags). Update merges per key; a null value deletes the key.
>
> **order\_by** `string`
>
> Issue ordering for responder 'issues': 'last\_activity' (default) or 'occurrence\_count'. A cursor is only valid for the ordering it was minted under.
>
> **resource** `string`
>
> What to operate on: 'responder' (a triage bot for one Slack channel or for PagerDuty incidents), 'incident\_settings' (the org's single incident-channel config), 'incident' (an incident channel + investigation session), or 'report' (recurring report over responders/incidents; runs live under it). Omit only for 'schemas' and 'ingest\_dashboard'.
>
> **triggers** `string`
>
> Responder create (required)/update. Up to 10 triggers from one provider, OR'd, each with its own conditions; no two identical. Slack: 'slack:message' and/or 'slack:usergroup\_mentioned' triggers, all in one Slack workspace. Usergroup mentioned requires a usergroup eq filter with a real Slack usergroup ID (S...), not a handle or user ID, in every OR group. Keep a channel restriction by default; only omit it when the user intends to watch across channels, explain the broader scope, and include at least one completed filter in every OR group (is\_thread\_reply alone does not count). Channel-scoped example: \[\{'event\_type': 'slack:message', 'conditions': \{'any': \[\{'all': \[\{'field': 'channel', 'operator': 'eq', 'value': 'C0123ABC456'}]}]}}]. Ask the user for the channel ID (or find it via devin\_list\_integrations / Slack tools); never invent one. PagerDuty responder: 'pagerduty:incident\_\*' triggers (default just 'pagerduty:incident\_triggered'); an event type may repeat with different conditions, plus pagerduty\_connection\_id. Never mix the two providers. On update the list replaces wholesale.
>
> **dashboard** `string`
>
> 'ingest\_dashboard': reference to the dashboard to ingest — a URL, id, or name.
>
> **report\_id** `string`
>
> Report id for report get/update/validate\_update/delete/runs/run, and the optional filter for incident list (returns that report's candidate period + incidents to classify).
>
> **incident\_id** `string`
>
> Incident id for incident get/stop/resume.
>
> **incident\_ids** `string`
>
> Report 'runs' POST: incident ids classified into the report for this period (from incident list with report\_id). Supplying this (even \[]) submits a run instead of listing runs.
>
> **responder\_id** `string`
>
> Responder id for responder get/update/validate\_update/delete/issues.
>
> **notifications** `string`
>
> Report create only: \{'slack': \{'channel\_id': 'C...'}} delivers each run to that channel. Recommend it when the user names a channel or one is obvious (e.g. the team's channel); never invent an ID. Cannot be changed on update.
>
> **response\_mode** `string`
>
> incident\_settings: response mode, 'proactive' or 'one\_shot\_rca'. Omit to preserve it; pass '' to clear it to the application default.
>
> **slack\_team\_id** `string`
>
> incident\_settings: Slack workspace ID incidents are watched in (omit for one workspace). Pass '' on update to clear the stored workspace.
>
> **responder\_tags** `string`
>
> Report create/update: tag-managed membership — every responder whose metadata matches ALL these key/values (e.g. \{'team': 'payments'}), resolved live at each run. Preferred when the user describes members by team/service.
>
> **incidents\_match** `string`
>
> Report create/update: natural-language description of which incidents belong in this report (e.g. 'incidents affecting the payments service'). Omit for a responders-only report; pass '' on update to clear it.
>
> **session\_settings** `string`
>
> Responder: devin\_mode (omit on create for the server default — the best of ultra > fusion > normal the org can use; Ultra is recommended for Oncall) and net\_policy (omit on create for the default from 'schemas': the deployment Git Manager-only policy, or the governing security profile's allowlist when one governs the network; explicit null = unrestricted, only when the user asks). On update, preserve unless asked.
>
> **auto\_join\_enabled** `string`
>
> incident\_settings: whether Devin auto-joins new public channels matching the prefix (default true — keep it on unless the user wants to invite Devin manually).
>
> **slack\_channel\_prefix** `string`
>
> incident\_settings: prefix for auto-created incident channels (server default 'inc-'). Pass '' on update to clear the stored prefix.
>
> **pagerduty\_connection\_id** `string`
>
> PagerDuty responders only: the account's PagerDuty connection id the responder posts incident notes through — read it from 'schemas' (pagerduty\_connection\_id; null means PagerDuty is not connected / not enabled for this org, so no PagerDuty responder can be created). Required with pagerduty:\* triggers, rejected with slack:message.
>
> **responder\_automation\_ids** `string`
>
> Report create/update: fixed responder membership (ids from responder list). Mutually exclusive with responder\_tags; on update the list replaces wholesale.
>
> **incident\_session\_settings** `string`
>
> incident\_settings: devin\_mode plus the staged investigation overrides initial\_investigation\_mode and thread\_session\_mode. Omit either override to use the application default; explicit null clears it. net\_policy follows the deployment default and explicit-null semantics. The legacy session\_settings alias is also accepted.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin playbook manage
>
> **Slug:** `DEVIN_MCP_DEVIN_PLAYBOOK_MANAGE`
>
> Manage Devin playbooks with a single action-based tool.
>
> #### Input Parameters
>
> **body** `string`
>
> Deprecated alias for `content`. Prefer `content`; this is accepted only for backward compatibility with older callers/skills.
>
> **after** `string`
>
> Opaque cursor for 'list' pagination (from a previous response's end\_cursor).
>
> **first** `string`
>
> Page size for 'list' pagination (default 100, max 200).
>
> **macro** `string`
>
> Automation macro identifier. Must start with '!' followed by word characters (letters, digits, underscores), e.g. '!my\_macro'. Optional.
>
> **title** `string`
>
> Playbook title. Required for 'create' and 'update' (v3 PUT is full-replace).
>
> **action** `string ("list" | "get" | "create" | "update" | "delete")` *required*
>
> Operation to perform: 'list', 'get', 'create', 'update', or 'delete'.
>
> **content** `string`
>
> Playbook markdown content. Required for 'create' and 'update' (v3 PUT is full-replace).
>
> **playbook\_id** `string`
>
> Playbook id. Required for 'get', 'update', 'delete'.
>
> **structured\_output\_schema** `string`
>
> JSON Schema (Draft 7) defining the required output contract for sessions using this playbook. Max 64KB. Optional for 'create' and 'update'.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin review manage
>
> **Slug:** `DEVIN_MCP_DEVIN_REVIEW_MANAGE`
>
> Trigger a Devin Review for a pull/merge request, fetch the latest review status for one, or fetch a completed review's findings. Only available in private mode (via devin.ai endpoints). The repo must be connected to the authenticated organization.
>
> Reviews run asynchronously: 'trigger' accepts the review (status starts as 'pending'); poll with 'get\_status' until it reaches 'completed', then use 'get\_findings' to read the findings ('get\_findings' returns an error until the review completes).
>
> #### Input Parameters
>
> **action** `string ("trigger" | "get_status" | "get_findings" | "report_triage")` *required*
>
> 'trigger' starts a Devin Review for the PR; 'get\_status' fetches the latest review status for the PR; 'get\_findings' fetches the findings of a completed review. By default, only the severities the org delivers to sessions are returned; the rest remain available on the Devin Review page and can be fetched by passing the severity explicitly. 'report\_triage' reports what you did about each finding of a review in a single call; findings marked needs\_human are then posted on the PR.
>
> **pr\_url** `string` *required*
>
> Full URL of the pull/merge request (e.g. '[https://github.com/owner/repo/pull/123](https://github.com/owner/repo/pull/123)').
>
> **severity** `string`
>
> get\_findings only: filter findings to one severity ('bug', 'security', 'flag', or 'info'). Bug means a concrete correctness, regression, or repo-rule violation; security means a vulnerability or hardening gap; flag means something needing further investigation that may or may not be a bug; info means an informational note. Omit to return only the severities the org delivers to sessions; the remaining severities stay available on the Devin Review page and can be fetched by passing the severity explicitly.
>
> **decisions** `string`
>
> report\_triage only: one decision for every finding of the review.
>
> **commit\_sha** `string`
>
> get\_status/get\_findings: commit SHA to look up (full or short prefix). Defaults to the PR's current head commit. report\_triage: required; the commit the findings were reported for.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin schedule manage
>
> **Slug:** `DEVIN_MCP_DEVIN_SCHEDULE_MANAGE`
>
> Manage scheduled Devin sessions (deprecated in favor of Automations).
>
> Note: "create" is only for organizations not yet migrated to Automations. For migrated organizations the API rejects it with 403 — schedule work by creating an automation with a schedule trigger via 'devin\_automation\_manage' instead. The other actions keep working for existing schedules.
>
> #### Input Parameters
>
> **name** `string`
>
> Human-readable name for the schedule. Required for 'create'.
>
> **agent** `string`
>
> Which agent to run: 'devin', 'data\_analyst', or 'advanced'.
>
> **limit** `string`
>
> Max number of results for 'list' (capped at 100).
>
> **action** `string ("list" | "get" | "create" | "update" | "delete")` *required*
>
> The operation to perform: 'list', 'get', 'create', 'update', or 'delete'.
>
> **offset** `string`
>
> Pagination offset for 'list'.
>
> **prompt** `string`
>
> The prompt Devin will run on each trigger. Required for 'create'.
>
> **enabled** `string`
>
> Enable or disable the schedule (used with 'update').
>
> **platform** `string`
>
> VM platform for sessions spawned by this schedule (e.g. 'windows'). When omitted, sessions fall back to the org's default platform at trigger time. Must match a platform configured for the organization (case-insensitive); unknown values are rejected with a 400 that lists the available platform labels.
>
> **frequency** `string`
>
> Cron expression (e.g. '0 9 \* \* 1-5'). Required for 'create' with recurring schedules.
>
> **notify\_on** `string`
>
> When to send notifications: 'always', 'failure', or 'never'.
>
> **playbook\_id** `string`
>
> Optional playbook to attach to the scheduled session.
>
> **schedule\_id** `string`
>
> The schedule ID. Required for 'get', 'update', and 'delete'.
>
> **scheduled\_at** `string`
>
> ISO 8601 datetime to run at. Required for 'create' with one\_time schedules.
>
> **schedule\_type** `string`
>
> 'recurring' (default) or 'one\_time'.
>
> **bypass\_approval** `string`
>
> Skip MCP tool permission checks for created sessions.
>
> **target\_devin\_id** `string`
>
> Devin session ID to send the prompt to instead of starting a new session. Only valid for one\_time schedules. Use this to schedule a message to be sent to an existing session at a future time (e.g. to wake yourself up later).
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin session create
>
> **Slug:** `DEVIN_MCP_DEVIN_SESSION_CREATE`
>
> Create one or more child Devin sessions via the v3 REST API.
>
> Only use this when prompted to; do not use it to parallelize your own work by default.
>
> Before calling this, invoke the managing-child-sessions skill for guidance.
>
> The returned session\_id values do NOT include the "devin-" prefix. To use them with devin\_session\_interact, prepend "devin-" (e.g. session\_id "abc123" becomes "devin-abc123").
>
> #### Input Parameters
>
> **tags** `string`
>
> Tags to apply to ALL created sessions (e.g. a shared run or campaign identifier). Each session spec can also include a 'tags' key to override this value for that session.
>
> **repos** `string`
>
> List of repository identifiers in 'owner/repo' format (e.g. \['myorg/myrepo']) to restrict ALL created sessions to. Each session spec can also include a 'repos' key to override this value for that session.
>
> **platform** `string`
>
> Prefer leaving this unset. When omitted (or set to 'inherit'), the child inherits the parent session's placement — its VM platform AND its outpost (BYOB) pool — so a Windows session spawns Windows children, and a session running on an outpost pool spawns children on the same pool, by default. Only set this when the user explicitly asks for a different machine type or a specific outpost pool: pass a platform label (e.g. 'linux', 'windows') or the name of an outpost pool. Each session spec can also include a 'platform' key to override this value for that session. Any value must match either a platform label or an outpost pool name registered for the org (built-in platforms take priority when a name matches both).
>
> **sessions** `array` *required*
>
> Array of session specs; only 'prompt' is required in each.
>
> **devin\_mode** `string`
>
> Devin agent mode for ALL created sessions, by the id of an option in the user's agent picker. Picker names → ids: 'Normal' = 'normal', 'Fast' = 'fast', 'Fusion' = 'fusion', 'Lite' = 'lite', 'Ultra' = 'ultra', 'SWE-2 Medium' = 'swe-2-medium', 'SWE-2 High' = 'swe-2-high', 'SWE-2 Max' = 'swe-2-max'. Always refer to modes by picker name when talking to the user, never by id. Batch-level only — a 'devin\_mode' key inside a session spec is rejected with guidance to move it to this batch-level field. When omitted, children run on the parent session's agent. Gated like the picker (feature flags and enterprise agent-mode policies); a 400 lists the modes available to this user.
>
> **board\_ticket\_ids** `string`
>
> Devin Boards ticket ids (from devin\_ticket\_manage) that ALL created sessions are dispatched to work on. Each session spec can also include a 'board\_ticket\_ids' key to override this value for that session. The server validates the ids against the org, persists them on the child and tags it 'board'; the CHILD claims the tickets itself on its first turn, so do not claim them before dispatching.
>
> **structured\_output\_schema** `string`
>
> JSON Schema (Draft 7) applied to ALL sessions that don't specify their own. Only pass this when you need a task-specific result from the child; without it no structured output is requested. The child reports output conforming to the schema via provide\_structured\_output; poll it via devin\_session\_interact(action='get') — the structured\_output field is populated without interrupting the child.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin session events
>
> **Slug:** `DEVIN_MCP_DEVIN_SESSION_EVENTS`
>
> Inspect events within a Devin session — list summaries, fetch full details, or search.
>
> Actions:
>
> * list: Paginated event summaries with optional filters.
> * details: Batch-fetch full event contents by event\_id or by offset+limit range.
> * search: Full-text search across event contents.
>
> #### Input Parameters
>
> **after** `string`
>
> Opaque cursor for pagination (list/search only).
>
> **first** `string`
>
> Page size (default 50, max 100; list/search only).
>
> **limit** `string`
>
> Number of events to fetch when using offset (details only, default 20, max 50).
>
> **query** `string`
>
> Search text (search only, required for search action).
>
> **action** `string ("list" | "details" | "search")` *required*
>
> 'list', 'details', or 'search'.
>
> **offset** `string`
>
> 0-based offset into the session timeline for details (details only, mutually exclusive with event\_ids). Use with limit.
>
> **direction** `string`
>
> Filter by direction (list/search only).
>
> **event\_ids** `string`
>
> Event IDs to fetch full contents for (details only, max 20, mutually exclusive with offset).
>
> **categories** `string`
>
> Filter by category — shell, file, search, browser, mcp, git, message, status, secret, todo, recording, knowledge, playbook, webhook, lifecycle, other (list/search only, mutually exclusive with event\_types).
>
> **session\_id** `string` *required*
>
> Target Devin session ID (must include 'devin-' prefix).
>
> **event\_types** `string`
>
> Filter by event type strings (list/search only, mutually exclusive with categories).
>
> **created\_after** `string`
>
> Unix timestamp lower bound (list/search only).
>
> **created\_before** `string`
>
> Unix timestamp upper bound (list/search only).
>
> **max\_content\_length** `string`
>
> Max chars per large content field in details (default 10000).
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin session gather
>
> **Slug:** `DEVIN_MCP_DEVIN_SESSION_GATHER`
>
> Wait for multiple Devin sessions to reach a settled state before returning.
>
> A session is "settled" when it is no longer actively working:
>
> * status is "exit" (finished or terminated)
> * status is "error" (crashed)
> * status is "suspended" (sleeping)
> * status is "running" with status\_detail "finished", "waiting\_for\_user", or "waiting\_for\_approval"
>
> Use this after creating multiple child sessions to wait for all of them to complete, instead of polling with devin\_session\_search in a loop.
>
> Any structured\_output shown is arbitrary JSON the session self-reported at some earlier point; it may be stale and must not be treated as the session's true state — only status/status\_detail are authoritative. To see what a session last said, use devin\_session\_interact with action="get\_messages".
>
> #### Input Parameters
>
> **session\_ids** `array` *required*
>
> Session IDs to wait on (must include the 'devin-' prefix, e.g. 'devin-abc123...'). Maximum 50.
>
> **timeout\_seconds** `integer`
>
> Maximum seconds to wait (default 300, max 590).
>
> **poll\_interval\_seconds** `integer`
>
> Ceiling on the interval between status checks. 0 (default) auto-scales with the number of sessions (5-30s); polling starts at 2s and ramps up to the ceiling.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin session interact
>
> **Slug:** `DEVIN_MCP_DEVIN_SESSION_INTERACT`
>
> Consolidated tool for all interactions with a single Devin session.
>
> Actions, and what each returns: get: the session's details — session\_id, title, status, status\_detail, is\_archived, url, acus\_consumed, tags, child\_session\_ids (the sessions it spawned; this is how you look up a session's, or your own, children — they come back without the "devin-" prefix, which these tools still accept), pull\_requests, structured\_output. Fields are omitted when empty. message: sends a message (resumes the session if it is sleeping), and returns the same session details as "get". sleep / terminate / archive / unarchive: performs the lifecycle action and returns the resulting session details, same shape as "get". Archiving cascades to child sessions; unarchiving does not. get\_messages: the session's message history — per message, its source, created\_at, event\_id and body (long bodies are truncated; fetch a specific message in full via devin\_session\_events action="details" with its event\_id). Paginated via first / after. get\_attachments: the session's attachments — name, content\_type, url. Not paginated. set\_tags: replaces the session's tags and returns the resulting tag list.
>
> #### Input Parameters
>
> **tags** `string`
>
> Tag list (required when action is 'set\_tags'). Replaces all existing tags on the session — this is a full replacement, not a union/append.
>
> **after** `string`
>
> Opaque cursor for get\_messages pagination (v3 cursor param).
>
> **first** `string`
>
> Page size for get\_messages pagination (v3 cursor param). get\_attachments is not paginated — v3 returns the full list.
>
> **action** `string ("get" | "message" | "sleep" | "terminate" | "archive" | "unarchive" | "get_messages" | "get_attachments" | "set_tags")` *required*
>
> Operation to perform — get, message, sleep, terminate, archive, unarchive, get\_messages, get\_attachments, set\_tags.
>
> **message** `string`
>
> Message text (required when action is 'message').
>
> **session\_id** `string` *required*
>
> Target Devin session ID, e.g. 'devin-abc123...' (the 'devin-' prefix is optional — bare IDs, such as the ones in child\_session\_ids, also work).
>
> **attachment\_urls** `string`
>
> Optional list of already-uploaded attachment URLs to attach to the message (only used when action is 'message'). Each URL must belong to the session's org — same mechanism as the initial prompt's attachments.
>
> **notify\_on\_response** `string`
>
> Only used when action is 'message'. When true, you are notified (and woken if sleeping) once when this session next settles (finishes, blocks, or exits). One-shot: consumed on delivery — pass it again on a later message to re-subscribe. Works for any session you are allowed to message (descendants, same-automation siblings, and sessions currently claiming tickets on a board you manage).
>
> **archive\_on\_terminate** `boolean`
>
> Also archive the session when terminating (default False).
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin session search
>
> **Slug:** `DEVIN_MCP_DEVIN_SESSION_SEARCH`
>
> Search and filter Devin sessions. All filters are optional and combined with AND.
>
> The returned session\_id values do NOT include the "devin-" prefix. To use them with devin\_session\_interact, prepend "devin-" (e.g. session\_id "abc123" becomes "devin-abc123").
>
> #### Input Parameters
>
> **tags** `string`
>
> Filter by tags.
>
> **after** `string`
>
> Opaque cursor for pagination (from a previous response's end\_cursor).
>
> **first** `string`
>
> Number of results per page (default 20, max 100 — tool-level cap below server's 200).
>
> **origins** `string`
>
> Filter by origin. Valid values: 'webapp', 'slack', 'teams', 'api', 'linear', 'jira', 'scheduled', 'cli', 'other'.
>
> **user\_ids** `string`
>
> Filter by user.
>
> **playbook\_id** `string`
>
> Filter by playbook.
>
> **schedule\_id** `string`
>
> Filter by schedule.
>
> **session\_ids** `string`
>
> Filter to specific session IDs (must include the 'devin-' prefix, e.g. 'devin-abc123...').
>
> **created\_after** `string`
>
> Unix timestamp lower bound for creation time.
>
> **updated\_after** `string`
>
> Unix timestamp lower bound for update time.
>
> **created\_before** `string`
>
> Unix timestamp upper bound for creation time.
>
> **updated\_before** `string`
>
> Unix timestamp upper bound for update time.
>
> **billing\_tag\_ids** `string`
>
> Filter by billing tag. Values are billing tag ids (see devin\_billing\_tag\_manage) or the special values 'miscellaneous' (explicitly tagged Miscellaneous) and 'uncategorized' (never tagged); a session matches if it matches any value. Only available for organizations with billing tags enabled — the search fails with an error otherwise.
>
> **parent\_session\_id** `string`
>
> Filter to child sessions spawned by this parent session (accepts the 'devin-' prefix).
>
> #### Output
>
> **result** `string` *required*

> [accordion] Devin user list
>
> **Slug:** `DEVIN_MCP_DEVIN_USER_LIST`
>
> List the current organization's users, one membership kind per call. Rows are `user_id | email | name` (roles appended with include\_roles).
>
> #### Input Parameters
>
> **after** `string`
>
> Opaque cursor for pagination (from a previous response's 'after=' notice).
>
> **email** `string`
>
> Exact email address to filter by (case-insensitive).
>
> **first** `string`
>
> Number of results per page (default 20, max 100).
>
> **membership** `string ("direct" | "idp")`
>
> 'direct': users added to the organization individually, with roles assigned to them. 'idp': users who are members via an identity-provider (SSO/SCIM) group mapped to the organization, with roles inherited from the group. A user can be both; list both to enumerate every member.
>
> **include\_roles** `boolean`
>
> Append each user's organization roles to their row (default false).
>
> #### Output
>
> **result** `string` *required*

> [accordion] Generate wiki
>
> **Slug:** `DEVIN_MCP_GENERATE_WIKI`
>
> Generate a codebase wiki for a repository. Triggers wiki generation and waits for completion.
>
> Only use this tool when the user explicitly asks to generate or regenerate a wiki. Do not call it proactively.
>
> #### Input Parameters
>
> **repoName** `string` *required*
>
> Repository in owner/repo format (e.g. "myorg/myrepo").
>
> #### Output
>
> **result** `string` *required*

> [accordion] List wiki repos
>
> **Slug:** `DEVIN_MCP_LIST_WIKI_REPOS`
>
> List the repositories that have a DeepWiki index, i.e. the ones that ask\_wiki\_question and read\_wiki\_\* can answer about. This is not the set of repositories you have access to: repositories without a generated wiki are omitted.
>
> #### Output
>
> **result** `string` *required*

> [accordion] Read wiki contents
>
> **Slug:** `DEVIN_MCP_READ_WIKI_CONTENTS`
>
> View documentation about a GitHub repository.
>
> #### Input Parameters
>
> **repoName** `string` *required*
>
> GitHub repository in owner/repo format (e.g. "facebook/react").
>
> #### Output
>
> **result** `string` *required*

> [accordion] Read wiki structure
>
> **Slug:** `DEVIN_MCP_READ_WIKI_STRUCTURE`
>
> Get a list of documentation topics for a GitHub repository.
>
> #### Input Parameters
>
> **repoName** `string` *required*
>
> GitHub repository in owner/repo format (e.g. "facebook/react").
>
> #### Output
>
> **result** `string` *required*
