dothething (DTT): a local AI agent that runs your task to completion

What dothething is for, and who it is actually for

The README states the premise in one line: "You give it a task, walk away, and come back to results." That is a different contract from a chat assistant. The agent is expected to break a plain-English task into steps, pick tools, and keep going until it either produces output or reports why it could not. The README lists the work it claims: research, data extraction, browser automation, file editing and code execution.

That shape suits a specific reader. Someone who wants a one-off artifact (a markdown report, an extracted dataset, a small script) and is willing to let a process run unattended for a while. The examples in the README are exactly that kind of job: find the ten largest public companies by revenue that went bankrupt in the last 20 years and write a markdown report; research the ten largest data breaches of 2025 and summarise the causes.

It suits less well anyone who needs a deterministic program. The agent decides which tools to call, and the README gives no schema for the output beyond the pipe exit codes. If you need a parser-stable result, this is the wrong layer.

How the loop works: planning, tools, and a local search stack

The mechanism visible in the README is a turn loop with a tool belt. The agent plans work and tracks progress, then calls tools. The loop is capped by --max-loops, which defaults to 200 turns and drops to 15 in quick mode. That cap is the main structural limit on how long a run can go.

Search is the most detailed part of the README. General-web engines are fetched through a real browser rather than a plain HTTP client, so the README says Google and similar engines "actually answer instead of serving a bot wall." Primary-source APIs (OpenAlex, Crossref, PubMed, arXiv) are queried directly and weighted above general web hits. That weighting is a design opinion: for research tasks, a paper record beats a blog post that summarises it.

Browsing runs on Notte and Camoufox, described as a Firefox fork built to avoid fingerprinting. The README says it extracts page content, solves captchas, and handles multi-step interactions. Captcha solving is tied to an optional 2Captcha key.

The model layer is role-based rather than single-model. The README names four roles (main, worker, oracle, browser) and states that grunt work goes to a cheaper model while a stronger one is consulted when the agent is stuck. Cost is tracked through OpenRouter, with Anthropic prompt caching named as a cost-reduction measure. Skills follow the Claude Code convention: only names and descriptions sit in context, and full instructions load on demand from ~/.dtt/skills/<skill-name>/SKILL.md.

Installing dothething and running a first task

The README gives a one-line install. It places the script at ~/.local/bin/dtt and adds that directory to PATH if it is missing. The same script runs without installing, so cloning the repository and invoking ./dtt.sh works too.

curl -fsSL dotheth.ing/dtt.sh | bash -s -- --install

The README notes that macOS usually has ~/.local/bin on PATH already while most Linux distributions do not, which is why the installer edits PATH. After install, the dtt command is available.

First run prompts for an OpenRouter API key, which is required, and a 2Captcha key, which is optional. Both are saved to ~/.dtt/env at mode 0600. To skip the prompt, export the key in your shell first; the README states that shell environment values take precedence over the saved file.

export OPENROUTER_API_KEY="your-key-here"
dtt --prompt "Find the 10 largest public companies by revenue that went bankrupt in the last 20 years and write a markdown report with causes and timelines."

Expect the first run to be slow. The README says it takes a couple of minutes to build a Python venv, install SearXNG and set up the Notte browser framework, all into /tmp/dothething. Later startups are described as fast.

If you omit --prompt, the agent opens a multiline editor. Type the task and press Esc+Enter to submit. For a job you want to bound, pass --max-loops or --max-cost; the README documents both as caps rather than estimates.

Modes, flags and the difference between quick and advanced

Three modes cover most of the range. Normal is the default and the README describes it as cheap and fast, naming DeepSeek Flash for the agent, Gemini Flash for the worker, Claude Sonnet for the browser and GPT-5.6 Terra for the oracle, all at xhigh reasoning. Advanced, selected with --advanced, swaps in what the README calls the strongest models (Claude Fable plus the Astra oracle) at max reasoning and is explicitly slower and more expensive. Quick, selected with q, -q or --quick, one-shots on Claude Opus Fast with a trimmed toolset: no oracle, no plan or notes bookkeeping, no batch machinery, and skills stay out of the prompt until invoked.

The quick-mode description is the most concrete part of the README. Its first reply stacks every tool call the job needs, staged with exec_order where order matters, and the next reply is the answer. The loop cap drops to 15 turns. That is a genuinely different execution model from the normal loop, not just a smaller model.

For scripting, --pipe is the flag that matters. It writes only the final report to stdout and suppresses everything else, with exit codes 0 for complete, 2 for partial and 1 for failed. That three-way exit code is more useful than a boolean, because partial completion is a real outcome for an agent that stops mid-plan.

Other flags worth knowing: --cwd sets the working directory for file operations and defaults to the current directory; --resume ID picks up a previous session and inherits its model, loop limit, working directory, browser session and display mode; --browser-session NAME reuses saved logins across runs; --headed and --headless control the browser window; --notify-desktop and --notify-email EMAIL report completion. The README marks --tui as experimental.

Where dothething gets uncomfortable: permissions, cost and failure

The honest limitation is authority. The README says the agent reads and edits files, runs shell commands and makes HTTP requests, and that it manages its own configuration by editing files and reloading itself. Nothing in the README describes a sandbox, a dry-run mode, or a rollback for a file edit or a shell command that went wrong. The one guardrail documented is --max-cost USD, which stops and checkpoints when cumulative cost reaches an amount. That is a spend limit, not a permission limit.

Cost is the second constraint. The README tracks token usage and dollar cost through OpenRouter and names Anthropic prompt caching as a reduction, but it publishes no cost figures for any mode. Advanced mode is described as slower and more expensive without numbers. Treat the first run as an unknown bill and set --max-cost.

Availability is the third. The README requires an OpenRouter API key and states that first-run setup installs SearXNG, the Notte framework and a Python venv into /tmp/dothething. A /tmp path is cleared on many systems at reboot, so a machine that reboots between runs may pay the setup cost again. The README does not say the setup is cached elsewhere.

The fourth is the boundary of the quick mode. It is a one-shot answer path with no oracle and a 15-turn cap. Using it for a research project is a category error the README itself warns against: quick is "for a fast answer, not a research project."

How it compares to Claude Code and other agent CLIs

The closest comparison the README invites is Claude Code, and it does so deliberately: skills follow the Claude Code convention, and the skill loader keeps only names and descriptions in context until a task matches. The difference in approach is the tool belt around the model. Claude Code is built around a coding session in a repository. Dothething is built around a task that may not touch code at all: it ships a local SearXNG instance, a Camoufox browser, primary-source API clients for OpenAlex, Crossref, PubMed and arXiv, email through AgentMail, and clipboard access including images.

That breadth is the trade. A coding agent keeps a narrow, well-understood surface. Dothething carries a search stack, a browser stack and an email identity, each with its own setup and its own failure modes. The README's own architecture reflects this: four model roles rather than one, a separate browser model, and an oracle consulted only when the agent is stuck.

If your work is editing a repository, a coding-focused agent is the simpler choice. If your work is gathering and assembling information from the web and from papers, the SearXNG and primary-source weighting in dothething is the part that is hard to replicate with a general agent CLI.

Maintenance, licence and upgrade cost

The repository is not archived, and the last push was on 2026-09-07. There are no releases in the repository, so upgrades are not versioned artifacts; the install path is a curl of dtt.sh from dotheth.ing, which means the script you get is whatever the site serves at that moment. The repository also carries a VERSION file and a version_up.sh script, which suggests version bumps are handled in-tree rather than through tagged releases. The README does not document rollback to a previous version, and there is no release list to roll back to.

The practical upgrade cost is the first-run setup. The README states that setup builds a Python venv, installs SearXNG and configures Notte into /tmp/dothething, and that this takes a couple of minutes. If that directory is cleared, the cost is paid again. Configuration lives in ~/.dtt, so keys in ~/.dtt/env and skills in ~/.dtt/skills survive a reinstall of the script itself.

On licensing, the repository is BSD-3-Clause. That is a permissive licence, and the README does not discuss commercial use, redistribution or warranty. Nothing here is legal advice; if you plan to redistribute the script or ship it inside a product, read the LICENSE file in the repository rather than the README.

Editorial conclusion

Adopt dothething if you want a task-runner that lives on your machine, drives a real browser and a local search stack, and keeps its own configuration under ~/.dtt. Do not adopt it if you need a hosted service, a stable CLI contract, or unattended runs where a wrong file edit is expensive, because the README documents no sandbox, no dry-run and no rollback. Before a first real job, verify three things: that ~/.dtt/env holds the keys you expect at mode 0600, that the copied ~/.dtt/mcp.json connects to your MCP servers, and that the default working directory (the current directory unless you pass --cwd) is one where the agent may edit and run commands. The README's own --max-cost and --max-loops flags are the two limits worth setting on that first run.

Frequently asked questions

Official sources

1. fluffypony/dothething on GitHub
2. Issues
3. License: BSD-3-Clause
4. Project website
5. README