Delegate

Hand real work to an agent on your own machine

Open a task in your DoBox, hand it to an agent, and get it back for review. The agent runs on your own computer through Claude Code or Codex, on the AI subscription you already pay for. It is not only for code: give it a document, an analysis or a piece of research and it works on the real thing.

Get started

Free during beta · No credit card required

What delegation is

Hand a task to an agent the way you would hand it to a person

Delegation starts from a task in your DoBox. Open it, choose an agent, and send it. Nothing has to be automated first, and nothing about it is specific to engineering.

You start it, or a workflow does

The everyday path is manual: you are looking at a task, you decide an agent should take a run at it, you delegate it. If you would rather a task be handed off the moment it meets some condition you care about, you can build a workflow that does it. Neither is more supported than the other.

Give it code, get a draft pull request

The agent gets its own git worktree off the local checkout, works there, and opens a draft pull request. The branch the assignee is in the middle of stays untouched, and nothing merges without a person.

Give it a document, get a draft back

Delegation is not only for engineering. Hand it a report, an analysis, a competitive teardown or a piece of research, and it works on the real file and comes back for you to review. Tasks like these need no repository at all; the result arrives attached to the task itself.

Your machine, or our cloud

Local delegation runs on the assignee’s own computer on their own subscription. Cloud delegation is there too, for when nobody wants to install anything. Almost nobody else offers the local option.

Local by design

Runs on your machine

When you delegate an issue to a coding agent, it typically runs in a cloud sandbox the vendor spins up for you. this+that can delegate to cloud agents too, and it adds another option: running the agent where your work already lives, on the assignee’s own computer, through Claude Code or Codex, connected through our desktop companion. It runs on macOS with Apple Silicon today, with Windows and Linux coming.

Your repo stays put

The agent works in the assignee’s own local checkout, in a git worktree of its own, so the branch they are in the middle of stays untouched. Nothing gets cloned into a vendor sandbox, and no copy of your repository is created anywhere else.

Your subscription, not an agent cloud

Delegation runs on the Claude or Codex subscription the engineer already pays for. There is no separate metered bill for agent compute and no per-seat agent pricing.

Draft PRs, human merges

Every delegated fix arrives as a draft pull request. A person reviews and merges it, every time. Nothing technical forces that: the loop could run hands-off, with a second agent reviewing, CI/CD deploying, and a workflow replying to the reporter. Keeping a person in the loop is a choice, not a limitation.

Or nothing leaves at all

Claude Code and Codex run on your machine but still call their provider’s API, the way they do in any terminal. Point delegation at a Qwen model served by Ollama on the same machine instead and there is no API call: the code, the model, and the work all stay on the laptop. That works today.

One worked example

A bug pipeline, end to end

Everything above works on its own, one task at a time, by hand. This is what it looks like when you wire the whole thing together instead: the workflow we built for our own bug pipeline. Nothing about it is scheduled: it starts when a bug report lands at support@. It is an example rather than a template. The inbox, the ownership map and the approval points are decisions we deliberately do not make for you, because the right answers differ in every team.

A bug report lands at support@

Reading every message that arrives is automatic. Telling a bug report apart from a billing question or a feature request is the part you define, once, in the workflow.
It becomes a task

The report turns into a task in the DoBox, with the original email attached so nothing gets lost in translation.
The Brain routes it

Assignment comes from what you have written in the Brain: which engineer owns which area of the product. We ship no opinion about who owns your code, so the bug goes to the person who knows it rather than into a round-robin queue.
The owner delegates it

Our desktop companion hands the task to Claude Code or Codex on that engineer’s own machine. The agent gets its own git worktree off the local checkout, so it can work without disturbing whatever branch that engineer is on.
A draft PR comes back

The agent opens a draft pull request and the review request goes wherever your workflow sends it. The task in the DoBox updates as each step happens.
The reporter gets a reply

When the review is approved, a workflow answers the original email: it is fixed, it ships soon, watch the changelog. The person who filed it never saw a tracker.

How we compare

Assigning work to an agent is mainstream now

Credit where it is due. GitHub Copilot’s coding agent takes an issue and opens a draft pull request. Linear lets you assign an issue to Devin, Codex, or Cursor the way you would assign it to a teammate. These are good products, and the approach they converged on is the right one: describe the work, hand it to an agent, review what comes back. We made the same bet early, so we are glad to see it validated.

We differ from them in two places.

Cloud sandbox vs your laptop

Their delegated agents run in cloud environments the vendor provisions, which makes setup easy and is a reasonable design; this+that can delegate to the cloud as well. The difference is the local option: the agent works in the assignee’s own checkout, on their hardware, through Claude Code or Codex, under the subscription they already pay for. No copy of your repository is made anywhere else. And if even the model calls have to stay home, point delegation at a Qwen model running under Ollama on that same machine: no API call leaves it.

Ticket to ticket vs email to email

Their loop starts at an issue and ends at a pull request or a ticket update, which works when the work originates inside engineering. But most work does not arrive as a well-formed ticket; it arrives as a message: a customer email, or a colleague flagging a bug in Slack or Teams. Our loop starts at the message and ends with a reply to whoever sent it. The tracker is in the middle of the loop, not the front door of it. And when work does start inside the team, that path works too: create the task directly in the DoBox and delegate it from there, the way we file our own issues.

Beyond code

A second example, with no code in it

A client asks for a summary of last quarter’s numbers. The task routes to whoever you have said owns the account, and the agent drafts the analysis on their machine for them to review. The same goes for the report a partner is waiting on, or the follow-up doc a prospect was promised. The agent drafts, a person reviews, and a workflow sends the reply.

Questions about delegation

What do I need to run this today?

A Mac with Apple Silicon, our desktop companion, a this+that account, and something for the agent to run on: Claude Code or Codex with your own subscription, or Ollama with a Qwen model if you would rather keep it entirely local. Windows and Linux are next.

What does the agent do to my repository?

It works in a git worktree off your own local checkout, so the branch you are on and any uncommitted work are left alone. Its changes come back as a draft pull request for you to review. It never merges its own work, and no copy of your repository is created outside your machine.

Does my code get sent anywhere?

It depends on which agent you point it at. With Claude Code or Codex, the repository itself stays on your machine, but the agent sends context to Anthropic or OpenAI to get its work done, exactly as it does when you run it yourself in a terminal. With a Qwen model served by Ollama on the same machine, no model call leaves the laptop at all. If your code cannot go to a third party under any circumstances, that is the configuration to use.

What does it cost?

Delegation runs on the Claude or Codex subscription the engineer already has, so there is no separate agent compute bill. Run it on a local Qwen model and there is no model bill at all. this+that itself is free during beta.

Can it handle work that is not code?

Yes. Any task in the DoBox can be delegated to a local agent, whether the deliverable is a pull request, an analysis, a report, or a follow-up document. A person reviews the draft before anything goes out.

Can I run it on a local model instead of Claude or Codex?

Yes. Delegation can be pointed at a Qwen model served by Ollama on the same machine the agent is working on, instead of at a Claude or Codex subscription. Quality depends on the model you run and the hardware you run it on, so it is a trade you make deliberately.

What is coming next?

Windows and Linux. macOS on Apple Silicon works today; Intel Macs are not supported, and builds of our desktop companion for Windows and Linux are in progress. No date on any of them yet; when they are live, we will say so plainly.

How is my data handled?

Delegated coding happens on your machine, and your repository is not sent to our servers. For the messages and tasks this+that stores, everything is encrypted in transit and at rest; message content, tasks, and brain pages are additionally encrypted under dedicated keys in AWS KMS that only the application’s service roles can use to decrypt, and no this+that employee or contractor has decrypt access. AI processing runs through Amazon Bedrock inside AWS, whose terms prohibit training on customer data. The full picture is on our security page.

Delegate your first task

Open a task, hand it to an agent on your own machine, and get it back for review. Code or knowledge work, either way. Free during beta, no credit card required.