Devin AI Docs: Map of Official Documentation

Cognition's official documentation index at docs.devin.ai/llms.txt lists 537 documentation entries. More than half sit under API reference (281 pages). Desktop (89), CLI (34), enterprise (26), and use cases (19) fill out the rest. That is not a thin help center. It is a full product documentation system for Cloud sessions, CLI, Desktop, integrations, and governance. Most third-party "Devin docs" posts never open that index. They restate homepage claims. This guide maps the real tree by intent.

Devin AI docs are Cognition's official documentation for setting up, operating, integrating, and governing Devin across Cloud, CLI, Desktop, and API workflows. The home is https://docs.devin.ai/. The machine-readable map is llms.txt. Start there when you need every page title and path, or when an agent should discover docs without scraping HTML.

Top 8 destinations by intent

1. First session: Introducing Devin and Your First Session
2. CLI: Devin CLI Quickstart
3. API: API Overview
4. MCP: Devin MCP, DeepWiki MCP, and CLI MCP Overview
5. DeepWiki: DeepWiki and Index a Repository
6. GitHub and other git hosts: GitHub and Git Integrations
7. Security and admin: Security at Cognition and enterprise security-access pages
8. Use cases and tutorial library: Use Cases Overview and Tutorial Library

How the site is organized

The docs are not one linear book. They split by product surface and by role:

• Get started and onboarding: first session, environment/blueprints, repo indexing, Knowledge, AGENTS.md
• Work with Devin: Ask Devin, DeepWiki, session tools, handoff, MCP marketplace, Devin Review, Security Swarm
• CLI: install, commands, sandbox, skills, hooks, MCP config, enterprise controls
• Desktop: Cascade, previews, analytics, account/RBAC pages for Teams and Enterprise
• API reference: Organization and Enterprise scopes, sessions, playbooks, knowledge, secrets, consumption metrics, OpenAPI specs
• Enterprise and federal: deployment models, SCM integrations, IP access lists, customer managed keys, federal compliance pages
• Use cases and product guides: migrations, backlog clearing, playbooks, secrets, scheduled sessions, automations

If you only bookmark one URL besides the home page, bookmark llms.txt. It is the authoritative page list Cognition ships for agents and humans who need the full map.

New users should ignore API and enterprise pages for day one. Cognition's get-started path is short and concrete.

Start here

1. Read Introducing Devin. Cognition describes Devin as an autonomous AI software engineer that can write, run, and test code. The page sets strength areas (parallel backlog work, migrations, repetitive engineering tasks, customer engineering support) and success patterns (clear prompts, verifiable completion criteria, well-scoped steps).
2. Run Your First Session so you see a full loop before you automate anything.
3. Configure the environment with Environment configuration or declarative blueprints so sessions boot with repos cloned, tools installed, and dependencies ready.
4. Index repos with Index a Repository to enable Ask Devin and DeepWiki. Indexing is separate from environment setup. Indexing feeds search and wiki. Environment setup builds the machine Devin works on.
5. Add durable context with Knowledge and AGENTS.md.

Tutorial library vs use-case gallery

The Tutorial Library is video-first: IDE walkthroughs, interactive planning, DeepWiki, Ask Devin, repo setup, and real team workflows (Slack bug handoff, IDE refactor, Linear backlog). Use it when you want to watch a workflow once, then copy the pattern.

The Use Cases Overview is project-shaped: Java upgrades, COBOL modernization, SAS to PySpark, JavaScript to TypeScript, NoSQL to SQL, and clearing engineering backlogs. Cognition states customers achieve 6-12x efficiency gains when they structure work as parallel, isolated, repetitive tasks with clear instructions. Treat that as vendor-reported guidance from the use-cases docs, not as an independent benchmark.

Essential guidelines worth reading early

Before you scale session volume, read:

• When to Use Devin
• Instructing Devin Effectively
• How Devin fits into the SDLC
• Prompt Templates Cheat Sheet

Those pages reduce failed sessions more than jumping straight into OpenAPI or enterprise RBAC.

Once Cloud sessions work, teams usually branch into three integration surfaces. Official docs keep them in separate trees. Mixing them is a common failure mode.

Devin CLI docs

Start at the CLI Quickstart. Official install paths include:

curl -fsSL https://cli.devin.ai/install.sh | bash

On macOS, Cognition also documents Homebrew:

brew install --cask devin-cli

Windows installers and a PowerShell setup script are documented on the same page. CLI docs also cover:

• Essential commands and full command/flag reference
• Sandbox behavior and permissions
• Skills, rules, AGENTS.md, hooks, plugins
• MCP configuration for external tool servers
• Hand off to cloud Devin sessions
• Enterprise auth, team settings, and controls

Read CLI docs when you want a local agent with optional cloud handoff, IDE ACP integrations (JetBrains, Xcode, Zed), or project-local config.

API reference

The API Overview describes REST access for apps and automation. Current structure centers on v3 scopes:

• Organization API: https://api.devin.ai/v3/organizations/* for sessions, knowledge, playbooks, secrets, and related org resources
• Enterprise API: https://api.devin.ai/v3/enterprise/* for cross-org analytics, audit logs, user management, billing, and infrastructure

Cognition recommends service users with role-based access control. Auth docs cover service keys (cog_ prefix), personal access tokens (closed beta), and migration from v1/v2. Teams and Enterprise quick starts live under api-reference/getting-started. OpenAPI specs are published as v1, v2, and v3 files for client generation.

Example pattern from the official overview (create a session with a service user):

curl -X POST "https://api.devin.ai/v3/organizations/$DEVIN_ORG_ID/sessions" \
  -H "Authorization: Bearer $DEVIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Fix the login bug in issue #42",
    "create_as_user_id": "user_abc123"
  }'

Use the API docs when you need scripts, CI jobs, or internal portals that create sessions, manage playbooks, or pull consumption metrics. Do not use the API overview as a substitute for first-session onboarding.

MCP docs (three surfaces, not one page)

Cognition documents MCP in several places. Treat them as different products:

1. MCP Marketplace in Devin: MCP (Model Context Protocol) Marketplace
2. DeepWiki MCP for public repo wiki tools: DeepWiki MCP
3. Devin MCP for authenticated private/public repos and platform control: Devin MCP at https://mcp.devin.ai/
4. CLI MCP config for local and remote servers: CLI MCP Overview
5. Desktop/Cascade MCP: Desktop Cascade MCP

Devin MCP docs state that org-scoped service user keys resolve the org automatically, while enterprise service user keys and personal access tokens need an X-Org-Id header. Legacy apk_ keys are not supported on the Devin MCP server. If a third-party tutorial only shows a single JSON snippet, cross-check it against the surface you actually need.

Where session files and handoffs land Devin sessions produce code, logs, recordings, and attachments. Teams often park those artifacts in git alone, local disks, or generic object storage such as S3 or Google Drive. That works until reviewers need a shared, searchable place outside a single repo clone.

For durable, multi-agent handoffs, a shared intelligent workspace is a better default than "zip and email." Fast.io gives agents and humans the same workspace, version history, and Intelligence Mode for semantic search over outputs. Agents can use the consolidated MCP toolset over Streamable HTTP at /mcp (legacy SSE at /sse). See the storage for agents guide for the current MCP access path, and start an org with a 14-day free trial when you want a coordination layer next to Devin, not a replacement for Devin's own docs.

Keep Devin session outputs in one shared workspace

Store PR-adjacent files, exports, and review packs where agents and humans share version history, Intelligence Mode search, and MCP access. Start a 14-day free trial for your organization.

Start 14-Day Trial

After basic setup and integration, most teams hit four doc clusters: wiki/search, source control, security, and org-scale admin.

DeepWiki and Ask Devin DeepWiki generates architecture diagrams, documentation, source links, and summaries for indexed repos. It appears in the Devin app sidebar and pairs with Ask Devin for codebase Q&A and high-context planning. Public DeepWiki at deepwiki.com covers public GitHub repositories without full private-org setup.

For large monorepos, Cognition documents steering via .devin/wiki.json (repo_notes and explicit pages) so important areas are not skipped by automatic planning. Indexing steps live in Index a Repository.

GitHub and other SCM integrations

GitHub cloud setup is documented at GitHub. Enterprise admins should start from Git Integrations, which covers connecting an SCM provider at the enterprise level, then granting specific Devin organizations group- or repository-level access. Related pages include GitHub Enterprise Server, Azure DevOps, GitLab (cloud and self-managed), Bitbucket, and PR template behavior.

Practical sequence:

1. Connect SCM in enterprise integrations (admin only)
2. Grant repository permissions to the right Devin organization
3. Index branches used in daily development
4. Configure environment/blueprints so sessions can build and test

Skipping permission grants is a common "Devin cannot see the repo" failure even when the SCM app install looks healthy.

Security and trust pages

Security at Cognition covers encryption in transit and at rest, access practices, third-party audit and certification status (as published by Cognition, including the March 2024 audit work described on that page), vulnerability reporting to security@cognition.ai, data retention, training opt-out for paid plans, and IP ownership of Devin output. The page also points to Cognition's Trust Center for current trust and compliance materials.

Enterprise security-access docs go further: custom roles/RBAC, IdP groups, IP access lists, customer managed keys for dedicated deployments, AI guardrails, and single sign-on setup pages for common identity providers. Federal customers get a separate federal docs tree for compliance, security, procurement, and FAQs.

When writing security reviews for your own stack, cite Cognition's pages for Devin controls. Do not invent certifications for adjacent tools. Fast.io, for example, provides granular permissions and an append-only audit log as product security features, without marketed compliance certifications.

Desktop, Windsurf, and product guides

Desktop docs (Cascade, previews, analytics APIs, domain verification, Teams setup) sit under /desktop/. Legacy Windsurf plugin paths still appear in the index. Product guides cover playbooks, secrets, scheduled sessions, automations, skills, session insights, auto-triage, and team invites. If you are looking for "how do we operationalize Devin after the demo," product guides and essential guidelines matter more than another marketing comparison.

Documentation only helps if people open the right chapter. Use these role-based paths instead of browsing the full 537-entry index.

Engineer evaluating Devin this week

1. Introducing Devin
2. First Session
3. When to Use Devin
4. Tutorial Library
5. One use-case page that matches your work (migrations, backlog, testing)

Platform engineer wiring automation 1. API Overview + Teams or Enterprise quick start

2. Authentication
3. Devin MCP if agents should call Devin tools
4. CLI Quickstart for local agents and handoff
5. OpenAPI specs for client generation

Security or IT admin 1. Security at Cognition and Trust Center

2. Enterprise security-access docs (RBAC, IdP groups, IP lists, keys)
3. SCM integration and repository permission model
4. Billing/usage pages under admin for ACU and plan mechanics
5. Federal docs only if you are in a government deployment path

Common dead ends

Searching "devin help center" and landing on marketing only: Go to docs.devin.ai or llms.txt.

• Copying one MCP JSON for every client: Desktop, CLI, DeepWiki MCP, and Devin MCP are different surfaces. Match the doc page to the client.
• Assuming GitHub install equals usable repos: Enterprise requires permission grants after the SCM connection.
• Using API docs as onboarding: Sessions still need environment setup, indexing, and clear prompts.
• Losing reviewable artifacts outside git: PRs capture code diffs. Session notes, exports, and client-facing files often need a shared workspace with version history. Local folders and S3 buckets work; Fast.io workspaces add Intelligence Mode, ownership transfer from agent to human, and branded shares when non-engineers must review outputs without a full repo checkout.

Keeping this map fresh

Docs change. Cognition publishes release notes under the docs site and marks some features as preview or closed beta (for example personal access tokens). Re-check llms.txt before you hardcode paths in runbooks. For agent onboarding to Fast.io's own surface, use fast.io/llms.txt the same way: page index first, then deep links.

Devin AI docs answer how to run Cognition's agent. They do not replace your team's storage, approval, and handoff layer. Use the official map for Devin. Use a durable workspace when multiple agents and humans need the same files after the session ends.

Searches for "devin ai docs" are smaller than core brand queries around Cognition and Devin, but the intent is clear: people want the official map, not another feature recap.