Skip to content
/
Tier A A12 UI passthrough

Devin

devin · devin.ai/

Primitive shape 5 total
Commands 1 Skills 2 MCP tools 2
00

Summary

Devin — Summary

Devin is Cognition AI's fully autonomous, cloud-hosted AI software engineer — not a plugin or CLI add-on, but a complete remote agent that operates in its own cloud microVM with a shell, browser, IDE, and long-horizon planning loop. It accepts tasks via a web UI, Slack, API, or CLI (devin binary), executes them in persistent "sessions" with computer-use tools (terminal, browser, file editor), and optionally opens pull requests when complete. The knowledge/skills/playbook system lets teams encode reusable procedures (SKILL.md files, knowledge entries, playbooks) so Devin behaves consistently across sessions without re-prompting.

Key distinguishing characteristics: fully remote execution (no local compute required), parallel session dispatch (run many Devin instances simultaneously), computer-use-level tool access (not just code generation but actual browser automation and terminal execution), enterprise-grade isolation (microVM per session), and integrations with GitHub/GitLab/Jira/Linear/Slack. Pricing is consumption-based (ACUs), not open source.

Closest seed: kiro — both are closed-source "Archetype 5" products with proprietary primitives and a spec/knowledge system. Devin differs by being fully cloud-hosted with no local-IDE requirement, by offering parallel agent dispatch at scale, and by using computer-use (browser + terminal) rather than an IDE hook system.

01

Overview

Devin — Overview

Origin

Devin was created by Cognition AI and publicly announced in March 2024 as "the world's first fully autonomous AI software engineer." Cognition was founded by Scott Wu, Steven Shi, and Walden Yan, with backing from Founders Fund, Stripe, and others. The product is closed-source and commercially operated.

Philosophy

Devin's philosophy is that AI should operate as a peer engineer, not a co-pilot. The product explicitly targets "ambitious engineering teams" who want to delegate full tasks — not autocomplete single lines. The positioning headline (as of 2025) is: "Parallel cloud agents for serious engineering teams."

Key manifesto themes extracted from marketing material:

  • "Tackle many tasks in parallel, before they end up in your backlog"
  • "If you can do it in three hours, Devin can most likely do it"
  • "Devin is most effective when it's part of your team and your existing workflow"
  • Devin is described as being able to "tackle Linear/Jira tickets, implement entirely new features, repro and fix bugs, build internal tools, and more"

Target Persona

Enterprise/startup engineering teams who want to delegate well-scoped, reproducible engineering tasks to cloud agents rather than having developers use a copilot interactively.

Key Differentiators vs. Other Agents

  1. Cloud microVM execution — each session runs in an isolated virtual machine, not on the user's laptop
  2. Computer-use tools — shell, embedded IDE, and browser available to the agent
  3. Parallel dispatch — teams can run dozens of Devin sessions simultaneously
  4. Session persistence — sessions can be paused, resumed, and handed off
  5. Organizational knowledge — shared knowledge/playbook system across the team
02

Architecture

Devin — Architecture

Distribution

  • Type: Closed-source SaaS (cloud agent)
  • Access surfaces: Web app (app.devin.ai), Slack bot, GitHub/GitLab integration, REST API v1/v2, Devin CLI

Installation

# Devin CLI (local companion, not the agent runtime)
# Install via docs — binary download
# Run against cloud sessions
devin  # interactive
devin session create "Fix auth bug in repo"

Runtime Architecture

  • Agent execution: Cloud microVM per session (isolated, no user infrastructure required)
  • Session tools available to the agent: Shell/terminal, embedded IDE (VS Code-style), browser (computer-use), file system
  • Devin CLI: Local CLI that creates sessions, streams output, and supports /handoff to escalate local Claude Code work to cloud Devin

Directory / Config Conventions

  • .agents/ — SKILL.md files following Agent Skills open standard (agentskills.io/specification)
  • AGENTS.md — project-level instructions Devin reads automatically
  • Knowledge entries: stored in Devin web app (org-scoped, retrieved semantically)
  • Playbooks: stored in Devin web app (step-by-step reusable procedures)
  • Secrets: stored encrypted in Devin org settings

Target AI Tools

  • Devin is its own agent runtime; not a plugin for Claude Code, Cursor, or Kiro
  • Integrates with: GitHub, GitLab, Bitbucket, Jira, Linear, Slack, MCP servers

Required Runtime

  • User machine: None — execution is fully remote in cloud microVMs
  • Devin CLI (optional, local): node/binary, requires API key

Language

Closed-source. Backend inferred to be Python/TypeScript based on API patterns. CLI is a binary distribution.

03

Components

Devin — Components

Primitives (documented publicly)

Skills (SKILL.md)

  • Format: Markdown files at .agents/skills/<name>/SKILL.md following Agent Skills open standard
  • Discovery: Devin auto-discovers across all connected repositories
  • Features: dynamic content injection via !`command` blocks, argument substitution ($0, $ARGUMENTS), trigger modes (["user"], ["agent"], ["auto"])
  • Examples documented: test-before-pr, deploy
  • Auto-suggested: Devin suggests creating SKILL.md files after learning repo workflows during sessions

Knowledge

  • Storage: Org-scoped entries in Devin web app (not in repo)
  • Retrieval: Semantic/trigger-based — Devin recalls relevant knowledge when context matches trigger description
  • Features: Macros (!deploy-checklist), folders, enable/disable per user, enterprise-level scoping
  • API: Full CRUD via REST API (/api/v1/knowledge/)

Playbooks

  • Purpose: Step-by-step reusable procedures stored in org settings
  • API: Full CRUD via REST API (/api/v1/playbooks/)
  • Invocation: Referenced in sessions by name

Sessions

  • What it is: Core execution unit — each session = one microVM + agent loop
  • API operations: create, list, retrieve, send-message, terminate, update-tags
  • Parallel: Multiple sessions can run simultaneously per org

Devin CLI

  • Binary: devin
  • Operations: create sessions, interactive mode, /handoff from local to cloud
  • Key subcommand: devin session create "<task>"

Devin MCP

  • DeepWiki MCP: Devin can use DeepWiki to index and search codebases
  • Devin MCP: Exposes Devin session management as MCP tools for other AI clients
  • External MCP: Devin sessions can connect to user-provided MCP servers

Automations

  • Scheduled sessions: Run Devin on a cron/schedule
  • Auto-triage: Automatically triage incoming issues
  • Autofix: Auto-create fix PRs for certain issue types
  • GitHub/GitLab webhooks: Trigger Devin on PR events

Devin Review

  • Purpose: AI-powered PR review (automated code review feature)
  • Trigger: Connects to GitHub/GitLab repos, reviews PRs automatically

Slash Commands (in-session)

  • /handoff — hand off from Devin CLI to cloud Devin
  • Other slash commands available in web UI (not fully enumerated in public docs)

Secrets Management

  • Stored encrypted in org settings; never exposed in logs
  • API: full CRUD (/api/v1/secrets/)

Snapshots / Environments

  • Session snapshots can be created and reused as base environments for future sessions
  • snapshot_id parameter in session creation API
05

Prompts

Devin — Prompts

Note on Closed-Source Status

Devin is closed-source; its internal system prompt is not publicly available. The following excerpts are from publicly documented SKILL.md examples in the official Devin documentation.

Example 1: SKILL.md — Test Before PR (from official docs)

---
name: test-before-pr
description: Run the local dev server and verify pages before opening any PR that touches frontend code.
---

## Setup

1. Install dependencies: `npm install`
2. Start the database: `docker-compose up -d postgres`
3. Run migrations: `npx prisma migrate dev`
4. Start the dev server: `npm run dev`
5. Wait for "Ready on http://localhost:3000"

## Verify

1. Read the git diff to identify which pages changed
2. Open each affected page in the browser
3. Check for: console errors, layout issues, broken links
4. Screenshot each page at desktop (1280px) and mobile (375px) widths

## Before Opening the PR

1. Run `npm run lint` and fix any issues
2. Run `npm test` and confirm all tests pass
3. Include screenshots in the PR description

Prompting technique: Checklist-style procedural decomposition. Uses imperative numbered steps. Separates Setup / Verify / Gate phases explicitly — mirrors the "test-driven-commit" pattern.

Example 2: SKILL.md — Deploy with Dynamic Context (from official docs)

---
name: deploy
description: Deploy the app to a target environment and run smoke tests.
argument-hint: <environment>
triggers: ["user"]
---

## Deploy

1. Make sure you are on the correct branch for this deploy
2. Run `./scripts/deploy.sh $0`
3. Wait for the deploy script to complete successfully

## Verify

1. Curl `https://$0.example.com/health` and confirm a 200 response
2. Run the smoke test suite: `npm run test:smoke -- --env=$0`
3. Report the deployment URL and test results

## Current context

- Branch: !`git branch --show-current`
- Last commit: !`git log --oneline -1`

Prompting technique: Dynamic context injection via !`command` blocks — live shell output is embedded into the prompt at invocation time. Argument substitution ($0) enables parameterized procedures. triggers: ["user"] prevents autonomous activation.

Example 3: Knowledge Entry Pattern (from official docs)

Knowledge entries follow this pattern:

  • Trigger description: "When deploying to production" (used for semantic retrieval)
  • Content: Free-form text with procedures, warnings, or reference info
  • Macro: !deploy-checklist (short identifier for explicit inline reference)

Prompting technique: Retrieval-augmented prompting. Knowledge items are semantically matched and injected into the agent's context. Not injected wholesale — only relevant items are recalled per session.

09

Uniqueness

Devin — Uniqueness

Differs From Seeds

Devin is most analogous to kiro in the seed set (both are Archetype 5 — closed-source products with proprietary primitives and a spec/knowledge system). However the architectural delta is substantial: Kiro is a local IDE fork that the developer installs and interacts with directly; Devin is a fully remote cloud agent where the developer is a manager, not a pair programmer. Kiro's hooks are IDE lifecycle events; Devin's "hooks" are webhooks (PR opens → session starts). Kiro stores specs in .kiro/; Devin stores knowledge in a cloud database with semantic retrieval. Neither is close to the open-source skill-based frameworks (superpowers, spec-driver, BMAD) because Devin requires no user-authored CLAUDE.md or methodology installation — the agent methodology is baked into the closed-source runtime.

Distinctive Opinion

Devin's bet is that "sessions" with a remote computer-use agent (shell + browser + IDE) will replace interactive copilots for any task that takes more than ~30 minutes and has clear verification criteria (CI, tests, screenshots).

Positioning

  • Primary competitor: GitHub Copilot Workspace, Cursor, factory.ai/Droid (all in this batch)
  • Key differentiator vs. Copilot/Cursor: fully autonomous, no human in the loop during execution
  • Key differentiator vs. factory.ai: older market presence, microVM isolation, consumer and enterprise plans

Observable Failure Modes (from docs)

  • "Devin may not function exactly as referenced" — admitted accuracy caveat in docs
  • Best results require "clear prompts with explicit completion criteria"
  • Complex tasks should be "broken into well-scoped steps"
  • Implied: vague tasks produce poor results; Devin works best on tasks with observable success criteria (CI passes, test output, screenshot)

Anti-Patterns (implied from documentation)

  • Do not give Devin tasks without explicit completion criteria
  • Do not expect Devin to handle "extremely difficult tasks" (>3 hours of human work per their own guidance)
  • Do not skip AGENTS.md and Knowledge setup — cold-start sessions produce lower quality

Cross-References

  • Uses Agent Skills open standard (agentskills.io/specification) for SKILL.md — same spec that Zed's skill system is also aligned with
  • Competing with factory.ai Droid and Cosine in the "cloud coding agent" category
04

Workflow

Devin — Workflow

Primary Workflow (Session-Based)

Phases

Phase Description Artifact
Task intake User submits task via web UI, Slack, CLI, or API Session created in cloud microVM
Context loading Devin reads AGENTS.md, recalls relevant Knowledge, looks up Skills Agent context window populated
Exploration Shell + file system exploration, codebase indexing (DeepWiki optional) Internal understanding
Planning Agent decomposes task into steps (internal planning loop) Session timeline visible to user
Implementation Code editing, bash execution, browser interaction Code changes in microVM
Validation Run tests, linters, build — agent decides what to run Test output in session
PR creation If configured, Devin opens a PR Pull request in GitHub/GitLab
Session end Agent reports completion; user reviews Session summary + PR link

Approval Gates

  • Tool execution approval: Devin can be configured to ask for confirmation before certain actions
  • PR review: User reviews and merges PR (Devin does not auto-merge by default)
  • Session takeover: User can "take over" Devin's session in the embedded IDE at any point
  • Interrupt/redirect: User can send messages mid-session to redirect Devin

Parallel Workflow

Teams can run N sessions simultaneously against different tasks/repos:

Session A: Fix auth bug
Session B: Write unit tests for payments module  
Session C: Migrate Angular 16 → 18

Knowledge Recall Loop

Session start → Devin reads AGENTS.md → semantic search over Knowledge entries
→ relevant Knowledge items injected into context → Skills discovered in .agents/
→ task-relevant Skills surfaced to agent

Playbook Workflow

  1. Team writes Playbook in web UI (step-by-step procedure)
  2. Devin is given a task that references the Playbook
  3. Devin follows the Playbook steps exactly
  4. Devin reports completion for each step

Automation Workflow

GitHub webhook fires (PR opened) → Devin Review auto-activates → review posted as comment
OR
Cron schedule triggers → Scheduled Session created → task runs unattended → PR opened
06

Memory Context

Devin — Memory & Context

Memory Types

1. Knowledge (Org-scoped, Persistent)

  • Storage: Devin cloud database (not repo files)
  • Scope: Organization-wide, shared across all users
  • Persistence: Permanent (until manually deleted)
  • Retrieval: Semantic/trigger-based — not injected wholesale; Devin recalls when relevant
  • Write path: Web UI, API (/api/v1/knowledge/), or Devin auto-suggestion

2. Skills (Repo-scoped, File-based)

  • Storage: .agents/skills/<name>/SKILL.md in git repositories
  • Scope: Per-connected-repository
  • Persistence: Version-controlled in git
  • Retrieval: Discovered automatically from connected repos; surfaced when relevant

3. AGENTS.md (Project-scoped, File-based)

  • Storage: Root of git repository
  • Scope: Per-project
  • Retrieval: Read at session start for every project

4. Session Context (Session-scoped, Ephemeral)

  • Storage: Session microVM memory + session timeline
  • Scope: Single session
  • Persistence: Session duration only (can be resumed)
  • Handoff: User can "take over" session; Devin CLI supports /handoff to escalate

5. Session Snapshots (Reusable Environments)

  • Purpose: Save a configured microVM state for reuse as session base environment
  • API: snapshot_id parameter on session create

Context Compaction

  • Unknown (closed-source); Devin likely manages context internally given sessions can be very long-horizon

Cross-Session Handoff

  • Devin CLI /handoff: Escalate from local interactive session to cloud Devin
  • Session resume: Paused sessions can be resumed
  • Session takeover: Human can take over in embedded IDE and hand back to Devin

State Files Written

  • .agents/skills/*/SKILL.md — skill definitions in repo
  • AGENTS.md — project instructions in repo
  • PR branches and commits in GitHub/GitLab
  • All other state is in Devin cloud (knowledge, playbooks, secrets, session data)
07

Orchestration

Devin — Orchestration

Multi-Agent Support

Yes — multiple Devin sessions can run in parallel, each in its own isolated microVM.

Orchestration Pattern

Parallel fan-out — teams dispatch independent sessions for independent tasks. There is no documented "hierarchical queen+worker" model between Devin sessions; orchestration is at the human/team level (assign different tasks to different sessions).

At the individual session level, Devin may internally decompose tasks into steps, but this is not exposed as a multi-agent protocol.

Isolation Mechanism

MicroVM per session — each session runs in a dedicated cloud virtual machine. This is the strongest isolation in the corpus: not just a git worktree or container, but a full VM with its own shell, file system, and browser.

Execution Mode

Interactive-loop — sessions accept messages, execute work, and report back. Can also be triggered programmatically (API, webhooks, automations) for background/scheduled operation.

Multi-Model Usage

Unknown — closed-source. Cognition AI uses proprietary models. External documentation does not specify which LLMs Devin uses internally or whether it routes different roles to different models.

Consensus Mechanism

None — no documented multi-agent consensus protocol.

Session Parallelism

  • Max concurrent agents: Not publicly documented (likely plan/tier-dependent)
  • Human-orchestrated: Humans decide which tasks to run in parallel; Devin sessions don't coordinate with each other

Crash Recovery

Yes — sessions can be resumed after interruption.

Streaming Output

Yes — session timeline streams in real-time to the web UI and Slack.

Context Compaction

Unknown — internal to Devin's agent runtime.

Prompt Chaining

Internal — Devin likely chains planning → implementation → validation internally, but this is not an exposed API.

08

Ui Cli Surface

Devin — UI & CLI Surface

Dedicated CLI

  • Exists: Yes
  • Binary name: devin
  • Distribution: Binary download (not npm/pip)
  • Key subcommands: session create, session list, interactive mode
  • Special: /handoff command to escalate local work to cloud Devin
  • Purpose: Control cloud sessions from terminal; run local→cloud escalation

Web Application (Primary UI)

  • URL: app.devin.ai
  • Type: Full web application
  • Features:
    • Session creation and management
    • Real-time session timeline (streaming output)
    • Embedded IDE (watch/take over Devin's code editing)
    • Shell output viewer
    • Knowledge management (create/edit/organize)
    • Playbook management
    • Secrets management
    • Team/org management
    • Analytics: PR metrics, session metrics, daily consumption
    • Audit logs (enterprise)
    • Session insights

Slack Integration

  • Type: Bot that can receive tasks and report session status
  • Features: Mention Devin in a thread to create a session; get status updates in Slack

IDE Integration

  • Type: Devin has an embedded IDE inside the session (for the agent's use)
  • User access: Users can open the embedded IDE to watch/take over Devin's work
  • Not a plugin: Devin does not install as a plugin in the user's local IDE

API Surface

  • REST API v1: Session CRUD, knowledge CRUD, playbooks CRUD, secrets CRUD
  • REST API v2: Enterprise management (orgs, users, audit logs, consumption analytics)
  • Webhooks: GitHub/GitLab PR events trigger Devin automations

MCP Integration

  • Devin MCP Server: Exposes Devin session management as MCP tools (usable by other AI clients)
  • Devin as MCP client: Sessions can connect to user-provided MCP servers

Observability

  • Audit logs: Enterprise plan — full audit log of all actions
  • Consumption analytics: Daily/per-user ACU consumption, PR metrics, session counts
  • Session insights: Per-session activity summary
  • Streaming: Real-time session timeline

Related frameworks

same archetype · same primary tool · same memory type

Goose (Block/AAIF) ★ 46k
A12 UI passthrough

General-purpose AI agent (not just code) with security-first tool inspection, recipe-based shareable configurations, and 15+ LLM…

Vibe Kanban ★ 27k
A12 UI passthrough

Eliminate the overhead of planning, switching between agent terminals, and reviewing diffs by providing a single web dashboard…

1Code ★ 5.5k
A12 UI passthrough

Cursor-like desktop experience for Claude Code and Codex with cloud background agents, event-driven automations, and a full…

Crystal (stravu) ★ 3.1k
A12 UI passthrough

Manage multiple parallel AI coding sessions in isolated git worktrees from a single desktop GUI.

Maestro (RunMaestro) ★ 3.0k
A12 UI passthrough

Orchestrate unlimited parallel AI agent sessions with a keyboard-first desktop app including Group Chat coordination and Auto Run…

AgentsMesh ★ 2.1k
A12 UI passthrough

Multi-tenant workforce platform that gives every team member a squad of AI coding agents coordinated through channels, pod…