← Guides · 日本語 · Português · 中文

Updated 2026-11-20

On this page
  1. What a Bot is
  2. Step 1 — Create it
  3. Step 2 — Assign the outcome
  4. A bounded first assignment
  5. Step 3 — Work with it
  6. Step 4 — Steer through memory, not micromanagement
  7. Before you share it — access and usage
  8. Step 5 — Put it where you work
  9. Step 6 — Schedules and modes
  10. Lifecycle
  11. Verify it
  12. Pitfalls
  13. Knowledge check
  14. Sources

Guide 1 — Your first Bot

Goal: create a Devin Bot that owns an outcome, and learn the six mechanics every later guide builds on. Level: start here · Time: ~15 minutes Source: official Bots docs, launch post

What a Bot is

A session does one request. A Bot owns an outcome: you state the goal once in its chat, it plans the work, starts a child Devin session for each piece, monitors them, and only brings you what needs your judgment. It persists — memory, sessions, and automations survive across weeks.

The six mechanics, in the order you'll meet them:

Mechanic What it is Where you touch it
Chat One thread for everything the Bot owns — goals, reports, questions The Bot's page / Slack / iMessage
Sessions Each piece of work runs as its own Devin session on its own machine Spawned and monitored by the Bot
Needs you Decisions, PR reviews, permission requests, reports — one list Top of the Bot's chat
Memory What the Bot learns, saved as files, read at every session start Settings → Memory
Instructions Standing rules people write, read at every session start Settings → General
Access The Bot's own connections/secrets, plus grants between Bots Settings → Access

Step 1 — Create it

Sidebar → Bots → Create new Bot → pick a template or Start from scratch → name it.

A new Bot is private to you until you share it. Its usage counts against your plan like any session.

Tip: the Template library (sidebar → Bots) lists Cognition's templates — QA Engineer, Migration Engineer, Data Analyst, … — plus ones shared inside your org; the same set is browsable without sign-in on the public Bot marketplace. Start from scratch is still the right choice for the guides in this repo — you'll write the outcome prompt yourself.

A template-created Bot gets the prompt and nothing else — it's private, with no connections, secrets or memory. Tell it in chat what it owns (repo, project, channel), wire its connections like any new Bot, and if the template is meant to run on a trigger the Bot offers to set that up on first contact. It keeps its own copy of the prompt — later template edits don't reach it. (Add to a current Bot sends a template's prompt to a Bot you already have instead of creating a new one.)

Step 2 — Assign the outcome

The first message is the most important input a Bot ever gets. Give it a goal, not a task:

You own the Android app now. Keep it at feature parity with iOS.

That's the verbatim prompt Cognition's Android Bot started from. Compare:

Weak (a task) Strong (an outcome)
"Fix the checkout button" "You own checkout. Keep it fast, correct, and covered by tests."
"Update the docs" "You own the docs. Keep them in step with main."
"Watch CI" "You own build health on main. When a check regresses, find the cause and fix it."

A task ends when it's done; an outcome makes the Bot re-plan forever.

A bounded first assignment

Ownership is the right shape, but bound the surface on the first run: one flow, one environment, one reviewer — you. The ANO field guide's pattern is the reliable starter:

Own the newsletter signup check for [project] on staging.
Use [repository], [staging URL] and the test mailbox I provide.
Check the journey from submitting the form to receiving the
correct welcome email and opening its resource link.

Start with one run. Show me the result before proposing a schedule.
If you find a defect, reproduce it, make the smallest suitable fix,
and open a pull request with the evidence.

Do not merge, deploy, email real subscribers, change billing,
or connect another service without asking me.

Return: what passed/failed, screenshots or a short recording,
the PR if a fix was needed, anything you could not verify,
and any decision you need from me.

The load-bearing lines: the journey definition (form → email → link, not just "form works"), one run before a schedule, the explicit no-merge/no-deploy fence, and the named evidence you expect back. Expand the assignment only after the Bot returns evidence you can trust twice.

Step 3 — Work with it

After the outcome is set, most of your messages are check-ins:

anything waiting on me?

Open Needs you (top of the chat) when the Bot flags something:

Item Your move
Decision Pick an option — the Bot marks its recommendation
Review PR / Merge PR Review or merge
Permission request Approve or reject new access, an automation, a network host, or a usage-limit increase
Report / FYI Read it

You can reply in your own words, snooze, or dismiss any item.

Step 4 — Steer through memory, not micromanagement

The pattern that scales: correct the Bot once, let it write the correction to memory, and every future session inherits it. Cognition merges 2,000+ PRs/week on this loop.

Before you share it — access and usage

Two things the launch posts skip that the docs spell out:

Step 5 — Put it where you work

Step 6 — Schedules and modes

Lifecycle

Action Effect
Recycle Terminates the current session; a fresh one starts next open. In the chat menu.
Archive Stops responses, removes it from Bot lists, removes its Slack app and inter-Bot grants (unarchiving doesn't restore those — you set them up again).
Delete Permanent: settings, sessions, memory, automations. Cannot be undone.

Only the creator and roles with Manage Bots see Archive/Delete. On Enterprise plans, Use Bots / Manage Bots / Manage Bots across the enterprise are separate permissions in custom roles.

Verify it

Pitfalls

Knowledge check

  1. What survives between a Bot's sessions that a one-off session doesn't have? (Memory — plus the standing outcome, schedules, and surfaces.)
  2. Why does a Bot "needs-you" instead of asking mid-session? (Judgment goes to one thread asynchronously; the human isn't a blocking call in the loop.)
  3. Which mechanic turns "a smart session" into "an employee"? (Ownership of an outcome — the goal persists after any single session ends.)

Sources