Skip to content

Product

The factory floor, in detail.

the chat, the agent's container, and the previews, docs and merge queue every change passes through.

Part of your own software factory. See the whole line

01Direct it

One shared session. Chat, terminal, or phone.

One session per workspace, shared by the whole team.

  • Messages from the chat, the terminal or your phone reach the same session.
  • Terminal is the live view. Conversation shows it as messages.
  • A browser editor with every repo. Pop out gives the session the full window.
upload-rate-limit Agent working
  1. S
    Sam09:41
    @agent rate-limit uploads, 20 a minute per user.
  2. A
@agentType here from the web, the desktop app or your phone.
02Track it

How far the work has got.

Columns are your stages. Drag a card to change its state.

  • Each card shows its tasks, deadline and whether an agent is working.
Backlog2
Invoice PDF export
0/4
0%
Q3 performance review
0/0Info only
In progress3default
upload-rate-limit@14
4/5Working
80%
Onboarding emails
2/6 2 days
33%
Mobile push channels
0/3
0%
Review1
Media share-link audit2
7/7 1 day late
100%
Completed4
Release 2.14.0
5/5
Fix flaky upload test
1/1
Nightly backup
3/3
Inbox3 unread, pushed to your phone
  • Alex mentioned you in upload-rate-limit09:50
  • Agent finished Onboarding emails, step 2 of 609:12
  • Nightly backup run was silent03:00
03Build it

What an agent has in its container.

The repos, the CLI, and a git that enforces your rules.

  • git pushes its own branch and refuses protected ones. A second check on our server refuses them too.
  • Tools use named credentials, stored encrypted.
  • It can start its own preview of the whole repo set.
upload-rate-limit, the agent's containerinside the container
agent › 
04See it

See it before you merge.

Every branch gets a live preview, a test run and a video of the change working, attached to its task.

  • Agents leave a note saying how each task was done.
  • The agent writes a take, and the video comes from running it.
Rate-limit uploads, 20 a minute per user
done #12 due Sep 14 Sam
  • Agenttodo → in progressSep 12, 09:41

    Reading the upload view and settings. Adding a per-user limit.

  • AgentSep 12, 09:45

    Tests: 42 passed in 3.1s. Preview is up on this branch.

  • AgentSep 12, 09:47

    Recorded the change working.

    settings / uploads
    Upload
    Filereport-q3.pdf
    Folder/reports
    Upload Uploaded report-q3.pdf
    Uploads this minute8 / 20
    Every user gets 20 uploads a minute.
    0:12 / 0:38
  • Agentin progress → doneSep 12, 09:48

    Opened !184, feature/upload-rate-limit → main. Needs a person to merge.

  • samSep 12, 09:52

    Watched it, clicked through the preview. Merging.

Add a note…Status: done ▾Add note
05Merge it

A person signs off on merges.

The agent opens the merge request. A person approves it unless an owner allows self-merge.

  • Every commit is authored as the person who asked for it.
  • Promotion follows your git flow. A release ships one version across every repo.
  • Undoing a merge goes through review too.
Merge requestsWaiting: 1feature → main
  • WaitingRate-limit uploads, 20 a minute per user!184 feature/upload-rate-limit → mainMerge
  • MergedFix flaky media upload test!181 feature/media-flake → main, by sam
  • MergedRelease 2.14.0release/2.14.0 → main, 3 repos, by alex
Release 2.14.0shippedgate → cut → record → ship → tag
  • Backendv2.14.0
  • Web appv2.14.0
  • Mobile appv2.14.0

One version across every repo, tagged by alex.

A chat the whole team can read.

One conversation per workspace, on the web, the desktop app and the phone.

@agent sends a message to the workspace's agent. Its questions appear as cards you can answer with a tap.

devbenchinside the container
  • $ devbench notify "<message>"

    Post to the workspace chat.

  • $ devbench notify "<message>" --video <url>

    Post with a video that plays inline in the thread.

  • $ devbench ask_question '<json>'

    Ask the team a question. They answer in the chat.

  • Replies quote

    Reply to a message and the quote goes with yours.

  • Mentions push

    A teammate gets a notification on their phone.

  • Permalinks and search

    Every message has a link. Search covers the thread.

  • Attachments play inline

    Images and video play in the thread.

  • Context

    The recent messages the agent sees with your request.

  • Live, with a fallback

    Messages arrive as they are sent. If the connection drops, the header says so.

  • Mute is yours

    Silences your own @mention alerts for this thread.

  • Interrupt the agent

    @agent interrupts the live session. Teammates see it.

A workspace

A branch across a set of repos, plus a container to work in.

Four questions. Only the first is required.

  1. 1

    Workspace

    The name, a description, an optional deadline, and whether it may change code.

  2. 2

    Repositories

    Pick an App and its repos come with it.

  3. 3

    Branching

    The branch to start from. Most keep your default.

  4. 4

    Environments

    Where each branch runs.

  • Info only, fixed at creation

    For work that reads code and never changes it: an audit, a review, an investigation.

    No working branch. git push and merge requests are refused. The output is a document.

  • Provisioning happens in the background

    The Inbox tells you when it is ready.

    Everyone opens the same container, so teammates share one editor and one terminal.

  • Stopping is safe and reversible

    Files survive a stop. Quiet workspaces stop on their own, unless set to keep running.

    Every automatic stop is logged in the Activity tab.

devbenchon your machine
  • $ devbench create -n "Name" -r <repo-id>

    Create a workspace from your own machine.

  • $ devbench setup <id>

    Clone a workspace locally, on its branch, in an empty folder.

  • $ devbench list

    Your workspaces.

Not an editor plugin.

A container with the repos, the CLI, and a git that enforces your rules.

  • A git that knows the rules

    git pushes the workspace's own branch and refuses your protected branches. A second check on our server refuses them too.

    agent › git push origin main
    refused: main is protected. Reach it through a merge request.
    
  • Commits authored as the person who asked

    DevBench is the co-author.

    agent › git commit -am "Rate-limit uploads, 20 a minute per user"
    [feature/upload-rate-limit a41c9e] Rate-limit uploads
    Author: Sam <sam@…> Co-authored-by: DevBench
    
  • The devbench CLI

    devbench mr create, devbench video record, devbench doc create, devbench deploy. The same commands you run yourself.

  • Tools with named credentials

    devbench tools run stripe --env test. Keys are stored encrypted and reach only the commands that use them.

  • A preview it can bring up itself

    The whole repo set, running as containers.

Where everything is.

The overview shows where the work has reached, its tasks and its activity.

  • Three views

    Board, Cards or Calendar.

  • The active column

    Only workspaces in it keep a container running.

  • Who sees what

    Owners and maintainers see every workspace. Members see their own and the ones assigned to them.

  • Filter and search

    Filter the board to one person, or search by name.

What was asked, its state, and how it was done.

One piece of work, with a status, due date and assignee.

Each task has a note timeline. Notes can carry a doc, a file, a link or a video.

Recheck against implementation has the agent compare the board with what is built.

Tasks for you

Tasks for you holds decisions, approvals and things to unblock. An item stays until someone closes it.

  • Detail goes in a linked document.
  • Repeat requests update the same item.
devbenchinside the container
  • $ devbench task add "<title>"

    Add a task from inside the workspace's container.

  • $ devbench task show <id>

    One task in full, with its note timeline.

  • $ devbench task note <id> "text" --video <url>

    Add context, or a recorded demo, without changing the task.

  • $ devbench task done <id> --note "how"

    Close it, recording how it was done.

  • $ devbench todo "<list>" <item>…

    A parent task with subtasks under it, in one command.

Recorded demos

A passing test shows the checks pass. A video shows the change working.

Each workspace can record its change running in the deployed app.

devbench/takes/upload-rate-limit.pya take, committed next to the feature
def take(t):
    t.goto("/settings/uploads")
    t.mark_ready()                      # everything before this is trimmed off
    t.say("Uploads are now limited to 20 a minute per user.", 4.0)
    t.beat("[data-testid='upload-form']", "The form itself is unchanged.", 3.0)
    t.click("button[type='submit']", after=2.0)
    t.beat(".toast", "The 21st request answers 429 with Retry-After.", 3.5)

A take is content

Committed in the repo, next to the feature it shows.

  • Captions and fixes

    Captions stay readable through the zoom. Fixing one never means re-recording.

  • Where the MP4 goes

    It is posted to the chat and attached to its task.

devbenchinside the container
  • $ devbench video check

    Checks that this container can record.

  • $ devbench video setup

    Installs what recording needs. No root access needed.

  • $ devbench video new <take>

    Scaffold a take next to the feature it shows.

  • $ devbench video record <take> --notify "…" --task <id>

    Record the deployed app, then post the video to the chat and the task.

  • $ devbench video rerender <take>

    Rebuild the MP4 after editing captions. Takes seconds.

Two tabs answer two questions.

Changes is the diff before a merge. Git shows what is uncommitted, pushed or in a merge request.

Changes

Push all commits and pushes every repo. Uncommitted work is not in a merge request.

Guardrails

The agent pushes its own branch, never a protected one. Reaching main takes a merge request or a release.

The rule is checked twice: in the container and on our server.

The git flow

Your organization sets one flow, from start to production. Agents cannot push directly to its branches.

devbenchinside the container
  • $ devbench mr status

    Uncommitted and unpushed work, per repo.

  • $ devbench ci

    CI runs and releases for this workspace's repos.

Where the work lands.

Four surfaces the agent writes to and the team reads from.

Merge requests

An agent opens them. A person approves by default.

Merge is the last read before a change reaches a shared branch.

  • History is kept

    Waiting is the queue; All is everything ever opened.

  • Reverting goes through review

    Undoing a merge opens a revert merge request, so it gets the same review.

  • Self-merge, per workspace

    Off by default. An owner can allow it for one workspace, and every use is announced to the organization.

devbenchinside the container
  • $ devbench mr targets

    The stages --target accepts, and which are open.

  • $ devbench mr create --target <stage>

    Open merge requests promoting this workspace's branch.

  • $ devbench mr list

    This workspace's merge requests, with ids.

  • $ devbench mr approve <mr_id>

    Land one. Only where the workspace allows self-merge.

  • $ devbench mr reply <mr> <discussion> "…"

    Reply to a review thread.

  • $ devbench mr resolve <mr> <discussion>

    Resolve a review thread.

Docs that know which answer is current.

Write a doc in the app, or publish one from the CLI. Share it publicly or keep it in the organization.

devbenchinside the container
  • $ devbench doc create <title> --file <path>

    Publish a doc and print its share link.

  • $ devbench doc list

    Docs and their share links.

  • $ devbench doc get <id>

    Print a doc's Markdown.

  • $ devbench doc from-memory

    Publish what the agent has learned about this workspace.

  • Subjects

    These three spellings file under one subject:

    Security Auditsecurity_auditSECURITY-AUDIT

  • How docs relate

    A link says how two docs relate.

    relates tofollowssupersedesderived fromanswerscontradicts

    Use supersedes when a newer doc replaces an older one. Use contradicts when two disagree.

  • A summary, read instead of the body

    Each doc has a summary to read in place of the body.

  • List and Graph

    List answers “where is that document”. Graph answers “what do we know about X, and what replaced what”.

Set up with you

Start with one real project.

We set up your factory with you and ship one project from your roadmap.