`dothething`: The Shell Script That Hides a Full AI Agent Stack
A local-first autonomous agent that bootstraps its own runtime, browser tooling, and multi-model council from one entry point.
- `dothething` is interesting because it makes a sprawling agent system look like a single command, then hides the real complexity in a self-updating bootstrap layer.
- Its strongest idea is not autonomy by itself, but governed autonomy: a primary model, a summarizer, and an oracle each have a distinct job.
- The project treats browser hardening, local persistence, and context compression as core infrastructure, not afterthoughts.
- It reads less like a framework and more like a portable machine for running long tasks on your own terms.
`dothething` is built on a simple bet: the best way to ship an agent is to make it feel small, even when the machinery beneath it is anything but. The repo presents itself as a shell script, but that wrapper is really a front door to a local runtime, a browser stack, a model router, and a persistence layer.
Why the one-script form matters
The distribution model is the first design decision worth noticing. A single entry point lowers the barrier to entry, but it also hides a lot of operational work: version sync, dependency setup, environment isolation, and state management in `~/.dtt/`.
| Dimension | dothething | AutoGPT / BabyAGI | Hosted agent platform | Framework-first stack |
|---|---|---|---|---|
| Entry form | One shell script | Python app or loop | Web app or hosted console | Library and SDK |
| Runtime location | Local machine | Usually local or mixed | Provider-controlled | Developer-chosen |
| State ownership | User-owned files and threads | Often local but ad hoc | Vendor-owned or vendor-managed | Depends on implementation |
| Browser strategy | Hardened browser stack with anti-fingerprinting | Often standard automation tools | Usually abstracted away | Left to the builder |
| Model routing | Primary, summarizer, oracle | Typically single-model or simple fallback | Platform decides | Builder wires it up |
| Long-task handling | Resume, summarize, and re-inject context | Varies widely | Platform-specific | Framework-specific |
| Best fit | Private, durable, local workflows | Experiments and demos | Managed deployment | Composable app development |
It handles research, data extraction, browser automation, file editing, and code execution.
Inside dtt.sh
The heart of the repo is `dtt.sh`, a polyglot bootstrapper that does more than launch code. It checks versions, updates itself, prepares a Python environment, and then hands off to embedded agent logic that can select from a large tool set.
# Simplified shape of the bootstrap pattern
if [ ! -d "$DTT_VENV" ]; then
python3 -m venv "$DTT_VENV"
fi
source "$DTT_VENV/bin/activate"
python3 -m pip install -r requirements.txt
check_for_update
maybe_self_replace
run_agent "$@"That is the operational trade-off in miniature. The script is not trying to be elegant in a software-architecture sense. It is trying to be installable, recoverable, and hard to break.
The model council
The most distinctive idea in `dothething` is not that it uses multiple models. It is that each model has a specific role in keeping the agent sane over time.
| Role | Model | Job |
|---|---|---|
| Primary | Claude Opus 4.6 | Make decisions and drive the task forward. |
| Summarizer | Claude Sonnet 4.6 | Compress tool output before it pollutes the main context. |
| Oracle | GPT-5.4 or GPT-5.4-pro | Provide a second opinion when the system is stuck or uncertain. |
That structure is a practical answer to three problems that kill long-running agents: reasoning quality, context growth, and fallback reliability. Instead of letting every tool result pile up in the main prompt, `dothething` filters the noise before it can crowd out the signal.
Ctrl-Q queues input for after the current step finishes Farms out grunt work to a cheaper model.
How it avoids drowning in context
This is where the project stops being a novelty and starts looking like infrastructure. Long agent runs do not fail because they cannot think once. They fail because they accumulate too much raw material, then lose the thread.
`result_mode` is the answer to that problem. Tool output can be summarized by a smaller model and re-injected as a compact state object, which keeps the primary model working with distilled evidence instead of a landfill of logs, pages, and traces.
if result_mode:
raw = run_tool_call()
summary = summarize_with_sonnet(raw)
context.append(summary)
else:
context.append(run_tool_call())That pattern is easy to miss, but it is the difference between an agent that feels decisive and one that slowly becomes incoherent.
Browsing like it has something to hide
The browser layer is not treated as a commodity. With Camoufox, Notte, and SearXNG in the stack, the repo acknowledges that real web automation means dealing with bot detection, fragile sites, and hostile interfaces.
| Browser approach | Strength | Weakness |
|---|---|---|
| Standard automation | Simple and familiar | Easy to fingerprint and block |
| Hardened browser stack | Better at navigating real sites | More moving parts |
| Hosted browsing | Managed by a vendor | Less control over identity and state |
That is another clue about the project’s philosophy. It is not trying to make the web friendly for agents. It is trying to make the agent resilient enough to operate inside the web as it exists.
Why this feels anti-SaaS
Taken together, the design choices point in a clear direction. The files live on your machine. The runtime persists under your control. The script updates itself, but it does so against a public version source rather than a hosted console that owns the workflow.
That makes `dothething` feel politically different from hosted agent products. It is less about platform gravity and more about user-owned execution, which matters when the task involves private files, browser sessions, and long-lived state.
What the pattern suggests
The lesson here is broader than one repo. If autonomous agents are going to move past demos, they need distribution that is easy to start, state that is durable, browser automation that can survive real sites, and model routing that treats uncertainty as a first-class event.
`dothething` is interesting because it compresses those requirements into a form that looks almost too small to matter. That is the point. The smallest public surface can still hide a very serious machine.
