How Devin AI Sessions Work: Shell, IDE, Browser, and Progress

DataForSEO measures about 50 US monthly searches for the phrase "devin session," with related seeds "devin shell" at 20 and "devin browser" at 10. The numbers are small, but the intent is clear: people searching these terms want the session UI and intervention model, not another list of prompt tricks.

A Devin session is a timed workspace where Devin AI plans or executes software work while you monitor and intervene through Shell, IDE, and Browser (Desktop) tools. Official Cognition docs describe those three surfaces plus a Progress tab that unifies shell commands, code edits, and browser activity in one view. That tools matrix is the practical core of running Devin AI well.

Sessions run against repositories you have indexed and set up on Devin's machine. When you start work from the session page, you choose between two primary modes:

• Ask mode for exploring the codebase and building a plan without changing code
• Agent mode for full autonomous work: writing code, running commands, browsing, and opening pull requests

Cognition's first-run guidance is direct. Unless you already have a fully scoped plan, start in Ask, construct a prompt with Devin, then send that plan into Agent mode. Session status from Ask-started Agent runs stays visible in the Ask conversation so you can track progress without losing the planning thread.

What you configure at launch

In Agent mode you select a repository that already lives on Devin's environment and pick an agent configuration. Available options include the default Devin agent for general engineering work, Fast Mode for quick well-scoped tasks, and Dana for data analysis and visualization. You can switch agent configuration mid-session with the toggle next to the message input. The change applies on your next message.

Context is easier to pin down with @ mentions. Official docs list mentions for repositories, files, macros, playbooks, skills (SKILL.md procedures in the repo), secrets, and prior sessions. Use them when a free-form prompt would leave Devin guessing which repo branch or credential store applies.

Success criteria and session size

Cognition recommends tasks with clear success criteria and enough context that a teammate could take the same handoff. Their rule of thumb: if a task would take you three hours or less, Devin can most likely do it. Larger projects should be split into focused sessions rather than one unbounded run. After a session finishes, Session Insights can generate a timeline, feedback, and an improved prompt for similar work later.

None of this replaces durable storage for artifacts you need after the session ends. Git remotes, object stores such as S3, shared drives, and intelligent team workspaces all sit outside Devin's sandboxed machine. Fast.io is one option for that layer when you want org-owned workspaces, per-file version history, and MCP access so agents and humans share the same files after Devin opens a PR.

Devin's shell gives full command-line access to the development environment. You can watch what Devin runs, inspect outputs, and run your own commands when you take over the machine. For many failures (failed installs, flaky tests, wrong branch, missing env vars), shell history is the fastest diagnostic surface.

Command history features

Official session-tools docs call out these shell history capabilities:

• Full command list of every command Devin executed in the session
• Output preview without leaving the history view
• Copy for commands and outputs via the three-dots control
• Time navigation by clicking commands to jump to different moments in the session
• Progress linkage so shell activity sits next to the sub-task Devin claimed it was solving

Commands shown greyed out are later in the session timeline. Clicking an earlier command moves you to that point so you can reconstruct the path Devin took before a bad commit or a failing suite.

During a live run, open progress updates for the step that looks wrong and expand the shell activity for that step. That is usually more efficient than reading the full chat transcript. If Devin retried the same failing npm test five times, you see it immediately in history and can stop the loop instead of waiting for another failed PR.

Running your own commands

When you take over Devin's machine, you get writable terminal access. You can open a terminal in the VS Code IDE, toggle terminals from read-only to writable, and run debug, test, or environment setup commands yourself. Use this when:

• You need a one-off diagnostic (git status, env | grep API, process list)
• Devin keeps choosing the wrong package manager or workspace root
• You want to reproduce a failure with a stricter flag set than Devin used
• You are preparing a clean state before resuming Agent mode

Shell history answers "what did Devin try?" Browser takeover answers "what is blocking login or a human-only gate?" Do not use shell history to solve CAPTCHA or MFA. Those belong in the Desktop tab.

Practical shell workflow

1. Let Devin start and produce a few progress steps.
2. Open Progress, then shell history for the step that diverged.
3. Copy the failing command and output if you need to paste it into chat or a ticket.
4. Pause Devin before making conflicting changes.
5. Run a tighter diagnostic yourself if needed.
6. Resume Agent mode with an explicit note of what you changed and what the shell proved.

That loop keeps you in control without micromanaging every command. It also produces an audit trail you can paste into a PR description or an internal incident note when the agent went down a wrong path.

Shell is not the only intervention surface. Devin AI also exposes an interactive VS Code IDE and an Interactive Browser under the Desktop tab. The Progress tab is the glue: every step's shell, edit, and browser activity lands in one place.

Devin IDE

Devin works in an interactive VS Code environment loaded with your repos. You can watch edits in real time, open files in new tabs, jump to definition, and use familiar shortcuts. When you need to own the keyboard, stop the session, then edit and test inside the same web IDE without leaving the Devin webapp.

Official docs highlight IDE features available during takeover:

• Cmd/Ctrl+K to generate terminal commands from natural language
• Cmd/Ctrl+I for quick questions or rapid file edits
• Tab autocomplete for code completion
• Terminals toggled from read-only to writable so you can run commands beside the editor

Best practices from Cognition's session-tools guide:

• Pause Devin before taking over the IDE so you do not fight simultaneous edits
• Use the browser on Devin's machine to test a local build without leaving the webapp
• Tell Devin what you changed when you resume the session

Use the IDE when the problem is code shape: wrong API shape, incomplete test, bad import path, or a two-line fix that is faster for you than another agent loop.

Interactive Browser (Desktop tab)

The Interactive Browser lives under the Desktop tab. Cognition renamed the tab from "Browser" to "Desktop" to reflect the full desktop environment, not only a single page. This is the surface for human-gated browser work.

Documented use cases include:

• Testing local applications running on Devin's machine
• Visual verification of UI changes
• Screenshots and recordings Devin can send back as proof of testing
• Authentication flows: login, MFA, OAuth
• Manually solving CAPTCHAs
• Helping with complex multi-step web UIs

Cookie and session data persist for the rest of the session after you interact. Log into a vendor console once, finish MFA yourself, and Devin can keep using that authenticated state while it continues the task. That is the main content gap many "prompt tip" articles miss: shell history cannot complete a CAPTCHA; Desktop takeover can.

Choose Desktop when the blocker is visual, auth-related, or website navigation. Choose shell when the blocker is CLI, build, or test output. Choose IDE when the blocker is source content.

Progress tab as the single pane

Click any step in a Devin session or open the Progress tab to see shell commands, code edits, and browser activity for that step in one unified view. Treat Progress as your default monitoring home. Drop into Shell, IDE, or Desktop only when a step needs action.

Featured comparison: when to use each tool

Cognition's own matrix matches this split. The mistake teams make is staying in chat only. Chat narrates intent. The tools surface what actually ran.

Keep Devin session outputs in one durable workspace

Store PRs' companion docs, screenshots, and handoff packages where agents and humans both can search and version them. Fast.io workspaces expose MCP endpoints and start with a 14-day free trial.

Start 14-Day Trial

Putting the tools together matters more than memorizing tab names. Here is a workflow aligned with official first-run and session-tools guidance.

1. Scope in Ask mode

Start in Ask. Ask how a subsystem works, request a plan with acceptance checks, and attach @Files or @Repos that bound the change. Ask mode uses advanced code search and produces cited answers without mutating the tree. When the plan is solid, construct a Devin prompt from that conversation and send it to Agent mode.

2. Launch Agent with a tight prompt

In Agent mode, select the right repository and agent. For a small, clear task, Fast Mode may be enough. For standard feature or bug work, use the default Devin agent. Include:

• The change request in one paragraph
• Files or patterns to touch and areas to leave alone
• How to validate (test command, manual path, coverage target)
• PR expectations (branch naming habits, description checklist)

Cognition's first-run examples stress verification steps after implementation: run named test files, confirm coverage thresholds, or run tsc after a TypeScript migration. Put those checks in the prompt so shell history has a clear "done" signal.

3. Monitor Progress, not every keystroke

After Agent starts, watch Progress. Healthy sessions show ordered steps with shell, edits, and occasional browser activity. Intervene early if Devin is on the wrong service, wrong package, or inventing an API that does not exist. Early redirects cost less than a finished bad PR.

4. Intervene with the right tool

• Failing tests or install loops: Shell history, then a writable terminal if needed
• Wrong code in a known file: pause and edit in the IDE
• Login wall, CAPTCHA, MFA, OAuth consent: Desktop tab, complete the gate once, keep cookies
• UI look-and-feel doubt: Desktop for visual verification, IDE for the underlying component

Always pause before dual control. Simultaneous human and agent edits in the same files create conflict and confuse the next Agent turn.

5. Resume with an explicit delta When you resume, tell Devin what you changed, which commands you ran, and what the new success check is. Official best practices call this out because the agent does not automatically infer every keystroke you made during takeover.

6. Finish with PR and durable artifacts

Agent mode can create pull requests and iterate on CI feedback. For long-lived docs, design notes, screenshots, or client deliverables that should outlive the session VM, push them to a durable store. Teams often use Git for code, S3 or a shared drive for large binaries, and a team workspace for mixed agent-human deliverables.

Fast.io workspaces fit the last case: org-owned storage, granular permissions, append-only audit log, Intelligence Mode for semantic search over the files Devin produced, and MCP access so other agents can read the same artifacts later. Plans start with a 14-day free trial (credit card required) on Starter ($29/mo), Business ($99/mo), or Growth ($299/mo). Agents can build structure, then transfer ownership to a human while keeping admin access. That handoff layer is separate from Devin AI itself. Devin remains the coding session; Fast.io is one place the outputs can live for the rest of the team.

Most Devin session problems are not "the model is dumb." They are mismatched intervention: waiting in chat while the fix lives in shell, IDE, or Desktop.

Looping on the same failed command Symptom: Progress shows repeated install or test commands with the same error. Action: open shell history, copy the failure once, pause Devin, fix the environment or pin a version yourself, then resume with the exact command that should pass. Do not ask Devin to "try again" without new information.

Agent stuck on authentication Symptom: chat says it cannot log in, or browser activity stops at a CAPTCHA or MFA screen. Action: open Desktop, complete the human gate, confirm cookies persist, tell Devin it is authenticated and which account was used. Shell history will not help here.

Conflicting human and agent edits

Symptom: your local patch and Devin's mid-session edits thrash the same files. Action: stop the session before IDE takeover. After you edit, resume with a short list of files you touched. Prefer one actor at a time on a given path.

Good plan, wrong execution surface

Symptom: Ask mode produced a strong plan, but Agent wandered into an unrelated package. Action: restart or redirect with @Files and @Repos pins, and reference the Ask-derived prompt rather than a vague "continue." If needed, take over the IDE for the critical path and hand back a narrower remaining task.

Session ends, artifacts scatter

Symptom: PR is fine, but notes, screenshots, and one-off scripts only existed on Devin's machine. Action: treat Git as source of truth for code. For everything else, copy to a durable workspace before the session is archived. Google Drive or Dropbox work for simple human sharing. S3 works for bulk binaries. Fast.io is stronger when agents need API or MCP access, version history, and search over the same files humans review.

Over-scoping a single session Symptom: a multi-day migration runs as one Agent session and thrash grows over time. Action: follow Cognition's sizing guidance. Split into sessions with clear acceptance checks. Parallelize independent slices when your plan supports it, rather than one endless sandbox.

What not to invent

Devin AI session tools are what Cognition documents: Shell, IDE, Desktop browser, Progress, Ask vs Agent, mentions, agent selection, and post-session insights. Do not assume undocumented menus, permanent free storage inside Devin, or automatic sync of the full sandbox to your laptop. Confirm behaviors against Devin session tools and the first-run guide when the product UI changes.