Latest / AI Builds It: Easy Coding Tools / Inside Devin’s Workflow: Tool Use, Planning, and Autonomy

Transcript

Inside Devin’s Workflow: Tool Use, Planning, and Autonomy · AI Builds It: Easy Coding Tools

• 0:00
  SPEAKER_00: Introduction.
• 0:01
  SPEAKER_00: Devon from Cognition AI is a new autonomous AI software engineer that can plan software development tasks and carry them out largely on its own.
• 0:11
  SPEAKER_00: It works end-to-end on code projects, using tools like a code editor, a command line shell, and a web browser to research, write, test, and deploy code.
• 0:22
  SPEAKER_00: In demos and press, Devon has been shown scanning a code base, generating a plan, editing files, running tests, and making pull requests with surprisingly little human input.
• 0:34
  SPEAKER_00: Cognition claims Devon can handle complex engineering tasks requiring thousands of decisions, recalling context at each step, and even learning from mistakes.
• 0:44
  SPEAKER_00: We therefore explore the public details of Devon's design and workflow.
• 0:48
  SPEAKER_00: This includes how Devon breaks down tasks, its planning process, how it literally works in a developer environment, editor, terminal, browser, how it keeps memory or context across a coding session, how it self-corrects and iterates, and what guardrails or safety measures it uses.
• 1:05
  SPEAKER_00: We also note what is not revealed.
• 1:08
  SPEAKER_00: For example, the exact model internals are undisclosed, so some community discussion relies on educated guesswork.
• 1:15
  SPEAKER_00: Task planning and decomposition.
• 1:17
  SPEAKER_00: When a developer gives Devon a new assignment, the first step is planning what files to change and in what order.
• 1:23
  SPEAKER_00: Cognition's notes explain that Devon uses a planning mode subagent whose job is to figure out which files in the repository are relevant to the task.
• 1:32
  SPEAKER_00: In practice, Devon investigates the repo and proposes a plan before writing any code.
• 1:38
  SPEAKER_00: For complex tasks, developers see this plan and can approve or adjust it.
• 1:42
  SPEAKER_00: If the agency mode is enabled, Devon will automatically proceed with its plan without waiting for approval.
• 1:48
  SPEAKER_00: Behind the scenes, Cognition trained this planning agent with reinforcement learning.
• 1:54
  SPEAKER_00: In one analysis, the team describes giving the planner only read-only tools, like LS, grep, or read file, and rewarding it when it correctly predicts the set of files a human would edit.
• 2:05
  SPEAKER_00: The result, Devon's planner learns to issue parallel file system queries, e.g., running LS and grep on different directories at once, and then narrow down promising leads.
• 2:15
  SPEAKER_00: The training penalty encourages efficiency, so the agent avoids brute force, e.g., grepping the entire repo endlessly, and instead promptly commits once it finds a target.
• 2:26
  SPEAKER_00: This means Devon's planning is data-driven.
• 2:29
  SPEAKER_00: It has learned generic code-based navigation strategies.
• 2:32
  SPEAKER_00: As Cognition notes, the model was trained on many repos and user queries.
• 2:36
  SPEAKER_00: At a user level, you see the result as an outline of steps.
• 2:40
  SPEAKER_00: For example, with a new feature request, Devin will suggest something like modify file A to implement X, add tests in file B, then update configuration C.
• 2:50
  SPEAKER_00: In demos, if a user forgot to specify some details, Devin's plan step often catches it and prompts for clarification.
• 2:58
  SPEAKER_00: In one demo, the assistant automatically added configuration of a GitHub account into the plan, even though the user did not mention it explicitly.
• 3:06
  SPEAKER_00: These steps of planning, asking questions, listing tasks, mapping files, are all done within Devon's dialog interface before any code is written.
• 3:15
  SPEAKER_00: If the user agrees or auto approval is on, Devon moves on to execution.
• 3:20
  SPEAKER_00: Working in a dev environment, editor, terminal, and browser, Devon operates within a sandbox developer environment.
• 3:27
  SPEAKER_00: Cognition's materials describe it as having a familiar developer toolkit, a shell terminal, a code editor, and a web browser all at its disposal.
• 3:35
  SPEAKER_00: In practice, when Devon runs, everything it does is logged and visible in the web UI.
• 3:41
  SPEAKER_00: A follow Devon view highlights each action, such as a file edit or shell command, and even lets a human click an icon to jump directly into either the code editor or the terminal where that action occurred.
• 3:53
  SPEAKER_00: For example, if Devon edits a JavaScript file, a user can click to see the VS Code editor view with the changes, or if Devon runs a shell command, click to see the terminal output.
• 4:05
  SPEAKER_00: You can also manually drop into Devon's workspace if you like.
• 4:09
  SPEAKER_00: A recent update added a Use Devon's machine button that opens Devin's environment in VS Code over the web.
• 4:17
  SPEAKER_00: This means a developer can peek at Devon's files, run commands, or even hand edit code in its workspace.
• 4:24
  SPEAKER_00: For long-running tasks, this is convenient if you want to inspect something mid-flight.
• 4:29
  SPEAKER_00: In one example, a user activated this to watch Devin create UI elements.
• 4:34
  SPEAKER_00: The user literally opened Devin's VS Code, saw the new files Devin wrote, and could explore the UI live.
• 4:41
  SPEAKER_00: The browser tool lets Devin research or test things on the internet.
• 4:45
  SPEAKER_00: In demos, Devin is seen using web search to look up documentation or libraries, and even running the local web server to check that its code isn't broken.
• 4:55
  SPEAKER_00: E.g., it will point a browser at localhost to verify the UI works.
• 4:59
  SPEAKER_00: All told, Devon's interface is multimodal.
• 5:02
  SPEAKER_00: It can take inputs like text prompts, attached design images or docs, and even code snippets, and it interacts through both chat and these developer tools.
• 5:12
  SPEAKER_00: The result is an experience much closer to a colleague writing code than a static chat with an AI.
• 5:19
  SPEAKER_00: Memory, knowledge, and session context.
• 5:21
  SPEAKER_00: Devon keeps track of information across a session using a built-in knowledge system.
• 5:26
  SPEAKER_00: Think of knowledge like a workspace notebook.
• 5:29
  SPEAKER_00: Devon can store tips, project-specific instructions, or important context there and recall it later.
• 5:35
  SPEAKER_00: For example, the docs describe workflows to pin certain knowledge so Devon never forgets it, such as important architectural constraints or coding style guides.
• 5:45
  SPEAKER_00: Users can edit or add to this knowledge bank.
• 5:48
  SPEAKER_00: Devon also will auto-generate helpful notes.
• 5:51
  SPEAKER_00: It scans your repository to learn about the code structure, components, and your documentation, and builds a repo knowledge summary automatically.
• 5:59
  SPEAKER_00: In practice, after you've run a few tasks, Devon might say, I noticed you often use React and Redux.
• 6:05
  SPEAKER_00: I suggest adding that to knowledge, and if you approve, that info is saved.
• 6:09
  SPEAKER_00: During a session, Devon will keep relevant knowledge in working memory.
• 6:14
  SPEAKER_00: Cognition claims it recalls relevant context at every step.
• 6:17
  SPEAKER_00: For example, if earlier it's learned that you prefer Python 3.11 or that your web app uses OAuth, it will bring that info into prompts as needed.
• 6:26
  SPEAKER_00: The session is inherently long and stateful.
• 6:29
  SPEAKER_00: You might talk to Devon for dozens of turns, minutes or more, while it edits many files, and it retains the chat history.
• 6:36
  SPEAKER_00: If Devon ever breaks, you can scroll the log or turn on progress mode to see every action it took.
• 6:42
  SPEAKER_00: If your session ends, for example, if you stop the task or wrap up, Devon forgets the running state of that machine.
• 6:48
  SPEAKER_00: And its virtual machine resets to a base snapshot next time.
• 6:53
  SPEAKER_00: By default, this base state includes the repositories you've preloaded in your workspace, so Devon doesn't have to clone from scratch every time.
• 7:02
  SPEAKER_00: Without workspace setup, each session would start with an empty machine, so Cognition emphasizes pre-configuring your repo for speed.
• 7:10
  SPEAKER_00: But beyond code, Devon does carry knowledge forward via its knowledge bank.
• 7:16
  SPEAKER_00: It will prompt you to add lessons or definitions that seem useful for future tasks.
• 7:21
  SPEAKER_00: Over multiple sessions, this means Devon gradually builds up a memory of your project's conventions and architecture.
• 7:28
  SPEAKER_00: In addition to knowledge, Cognition has released DeepWiki, a related tool that indexes entire code bases and provides a chat interface on top of them.
• 7:37
  SPEAKER_00: While DeepWiki is a separate product, it suggests the broader architecture.
• 7:42
  SPEAKER_00: Devon can query its own or an external wiki of the code to answer questions.
• 7:46
  SPEAKER_00: In practice, if you ask Devon something about the code, it may internally use the same retrieval systems as DeepWiki to ground its replies.
• 7:55
  SPEAKER_00: Autonomy, iteration, and self-correction.
• 7:58
  SPEAKER_00: Devon is designed to be autonomous, but with feedback loops when needed.
• 8:03
  SPEAKER_00: After planning, it executes steps one by one, constantly checking for errors.
• 8:08
  SPEAKER_00: In demos, the agent frequently follows this pattern.
• 8:12
  SPEAKER_00: It uses the browser or docs to understand a problem, writes some code, runs it, sees an error, and then looks up how to fix it, mimicking a human debug cycle.
• 8:23
  SPEAKER_00: For example, one presenter shows Devon adding a login form, then running the front-end test, finding a bug, and going back to research how to fix that error.
• 8:33
  SPEAKER_00: Each of Devon's turns is a loop of think, act, observe, correct.
• 8:38
  SPEAKER_00: Multiple sources note that Devon has self-correction built in.
• 8:42
  SPEAKER_00: Indeed, the cognition blog with GPT-5 mentions that GPT-5 is good at understanding errors and course correct itself, which they highlight as great for long tasks.
• 8:54
  SPEAKER_00: In other words, if Devon's code doesn't compile or fails a test, the model, often GPT-5 or similar, will see the error message and figure out a fix on the fly.
• 9:05
  SPEAKER_00: It's even capable of retry loops.
• 9:07
  SPEAKER_00: If an action partially succeeds, Devon may do a second pass.
• 9:12
  SPEAKER_00: These loops are visible in the UI as repeated edit and run sequences.
• 9:16
  SPEAKER_00: To systematically handle failures, Devon uses a mixture of automation and human oversight.
• 9:22
  SPEAKER_00: For example, if Devon opens a pull request and receives a CI failure or a code review comment, Cognition's system will automatically wake Devon from sleep and have it address the issue.
• 9:33
  SPEAKER_00: By default, Devon responds to lint errors or comments, although users can disable this.
• 9:39
  SPEAKER_00: The UI also highlights its status and actions in real time, so a developer can intervene at any time.
• 9:46
  SPEAKER_00: Developers are encouraged to watch the first few runs in live mode, where each step is shown to build trust, then let Devon run fully headless once confident.
• 9:56
  SPEAKER_00: Safety, guardrails, and customization.
• 9:58
  SPEAKER_00: Operators can give Devon explicit instructions on what not to do.
• 10:02
  SPEAKER_00: One powerful feature is forbidden actions.
• 10:05
  SPEAKER_00: You can list things Devon is not allowed to touch.
• 10:07
  SPEAKER_00: For example, do not push directly to main or don't edit file X.
• 10:12
  SPEAKER_00: The system ensures Devon respects these commands when they appear in the prompt or in a playbook.
• 10:17
  SPEAKER_00: According to release notes, Devon now handles forbidden action lists reliably, meaning it checks its actions against those rules.
• 10:25
  SPEAKER_00: This helps prevent common mistakes like modifying the wrong branch or file.
• 10:29
  SPEAKER_00: Devon also provides various controls.
• 10:32
  SPEAKER_00: In Slack or the web UI, you can tell Devon to sleep, pause work, or archive a session.
• 10:38
  SPEAKER_00: You can choose whether Devon requires your approval before executing a plan, via the agency setting, or runs fully autonomously.
• 10:46
  SPEAKER_00: Its compute usage is metered in Agent Compute Units, ACUs, and the UI shows warnings if Devon is about to hit limits, so you can intervene or grant more resources.
• 10:56
  SPEAKER_00: If something does go wrong behind the scenes, Cognition has monitoring in place.
• 11:01
  SPEAKER_00: In earlier releases, some users reported Devon's sessions stuck or crashed.
• 11:06
  SPEAKER_00: The team notes that those issues have been fixed and offers ACU refunds if Devon hangs.
• 11:12
  SPEAKER_00: In other words, the company is actively instrumenting the system for reliability.
• 11:16
  SPEAKER_00: Outside analysts caution that, like any chat-based AI, Devon can produce mistakes or hallucinate code on occasion.
• 11:24
  SPEAKER_00: The recommended practice is to review its output as you would a junior developer's work.
• 11:29
  SPEAKER_00: For safety, many teams use code reviews on Devon's commits and constrain Devon's permissions, e.g., no direct access to secrets by default.
• 11:38
  SPEAKER_00: So far, the publicly described guardrails are mostly user-defined, forbidden actions requiring plan approval, etc., and system health checks, rather than built-in ethical filters.
• 11:49
  SPEAKER_00: What we don't yet know, Cognition has intentionally kept some details internal, so parts of Devon are opaque.
• 11:56
  SPEAKER_00: For example, the exact large language model it uses was not initially public.
• 12:01
  SPEAKER_00: Rumors and later posts suggest Cognition now integrates GPT-5 into Devon for its planning and reasoning core, and they have a preview agent based on Claude Sonnet 4.5.
• 12:13
  SPEAKER_00: But the full architecture is unclear.
• 12:16
  SPEAKER_00: Devon likely orchestrates multiple models and has custom fine-tuning, as hinted by the RFT planning subagent, but those layers aren't open sourced.
• 12:26
  SPEAKER_00: We also do not fully know the limits of its memory.
• 12:29
  SPEAKER_00: Devon claims to learn over time, but how it merges new knowledge into its existing network versus just storing it in the knowledge bank is unspecified.
• 12:40
  SPEAKER_00: The maximum length of conversation history it effectively uses is not documented.
• 12:45
  SPEAKER_00: When a session is very long, it is possible earlier parts of chat or code context get pruned behind the scenes.
• 12:52
  SPEAKER_00: Practically, most users keep prompts and code concise to avoid context overload.
• 12:58
  SPEAKER_00: On the safety side, some unknowns remain.
• 13:01
  SPEAKER_00: For instance, while forbidden actions cover user-specified rules, it is not clear if Devon has any implicit safety layers, like detecting misuse of data, bias checks, or sandbox escapes.
• 13:13
  SPEAKER_00: Since it runs in a VM, one hopes it cannot damage host systems, but details on that sandboxing are not public.
• 13:20
  SPEAKER_00: The community infers that Devon's machine likely uses container snapshots, as mentioned for the RL training, to isolate runs.
• 13:28
  SPEAKER_00: Finally, many in the community are watching to see how Devon deals with ambiguous or open-ended tasks.
• 13:34
  SPEAKER_00: The sales pitch calls it fully autonomous, but analysts note it still often needs precise instructions.
• 13:40
  SPEAKER_00: For example, if the user's prompt is vague, Devon might generate a plan that seems reasonable, but misses important edge cases.
• 13:48
  SPEAKER_00: It may ask clarifying questions in follow-up, but developers sometimes wonder how well it understands intent versus just pattern matching on code.
• 13:57
  SPEAKER_00: These aspects of Devon's cognition rely on the underlying LLM's capabilities, which we only observe indirectly.
• 14:04
  SPEAKER_00: In short, users should judge Devon more as a highly skilled junior engineer than a product manager.
• 14:10
  SPEAKER_00: It plans well, but might not always grasp your intent perfectly.
• 14:14
  SPEAKER_00: Getting started with Devon, Devon is mainly aimed at engineering teams that do a lot of coding work.
• 14:19
  SPEAKER_00: It shines on clearly defined tasks, building features from specs, refactoring, writing tests, and fixing bugs.
• 14:27
  SPEAKER_00: It is less proven at high-level design or very ill-defined problems.
• 14:31
  SPEAKER_00: For a software team, Devon can help knock out routine work, so humans focus on the creative architecture and oversight.
• 14:38
  SPEAKER_00: For non-coders or newcomers, Devon can still be useful, but requires some setup.
• 14:44
  SPEAKER_00: The first step is to give Devon access to your code repository via GitHub, GitLab, etc., and perhaps connect it in Slack or Teams.
• 14:52
  SPEAKER_00: Then try a simple task.
• 14:54
  SPEAKER_00: For example, ask Devon, add a new page to list all products from our database in the web UI, including test coverage.
• 15:02
  SPEAKER_00: Watch the planning phase dialog.
• 15:04
  SPEAKER_00: Devon will outline which files to change, e.g.
• 15:07
  SPEAKER_00: HTML template, backend API code, etc., and ask any needed questions.
• 15:12
  SPEAKER_00: Approve the plan or let it auto-run and watch it execute.
• 15:16
  SPEAKER_00: Use the follow panel to see each step.
• 15:18
  SPEAKER_00: You'll see file edits, shell commands, like running test suites, and browser snapshots of the UI.
• 15:24
  SPEAKER_00: If Devin makes a mistake or you want to change, simply interact as you would in chat.
• 15:29
  SPEAKER_00: Actually, use this CSS theme, or the product title should be uppercase, and Devin will start another edit loop.
• 15:36
  SPEAKER_00: The key actionable step is iterate and review.
• 15:39
  SPEAKER_00: Always check the code Devin produces and tests it locally.
• 15:43
  SPEAKER_00: Over time you can enrich the knowledge bank, add notes like our database uses Postgres QL13 or we follow PSR12 style in PHP.
• 15:52
  SPEAKER_00: Devin will begin to incorporate these in future sessions.
• 15:56
  SPEAKER_00: Also explore the settings, turn agency off if you want to always vet proposals, or on if you trust it more.
• 16:03
  SPEAKER_00: Link Devon to your CI for automatic pull request review, but start with notifications so you can watch how it handles feedback.
• 16:10
  SPEAKER_00: Ultimately, Devon's workflow is dense and powerful, but it still relies on you for guidance.
• 16:18
  SPEAKER_00: By understanding how it plans, uses tools, and learns from feedback, as detailed above, you can get the most out of this new class of a gentic coding assistant.
• 16:29
  SPEAKER_00: The best next step for a team interested in Devon is to sign up on and run a small pilot.
• 16:36
  SPEAKER_00: Add one web repo, ask Devon to implement a feature, and let it run in progress mode.
• 16:42
  SPEAKER_00: Observe the full thinking trace.
• 16:44
  SPEAKER_00: That hands-on experience will clarify exactly how Devon weaves planning, editing, and self-correction together.
• 16:52
  SPEAKER_00: From there, you can scale up to more tasks and fine-tune its use.
• 16:56
  SPEAKER_00: For example, custom playbooks for your domain.
• 16:59
  SPEAKER_00: Though still evolving, Devon represents a major leap in AI tooling.
• 17:04
  SPEAKER_00: By learning its workflow today, teams can prepare for an era where coding tasks can truly be shared with an AI teammate.
• 17:12
  SPEAKER_00: All links to sources are available in the text version of this article.
• 17:16
  SPEAKER_00: You can find the full article at easycoding.tools.
• 17:20
  SPEAKER_00: Thanks for listening.
• 17:21
  SPEAKER_00: For more practical AI coding guides, tool comparisons, and resources for builders, visit easycoding.tools.
• 17:28
  SPEAKER_00: And if it's easier to remember, just go to aibuilds.it.
• 17:33
  SPEAKER_00: It redirects to easycoding.tools.