In December 2025 this was really useful working around some of the limitations of models, and maxing out their inherent capabilities.
Models and harnesses have moved on a lot since and most of these techniques work against what they now do natively.
Features↓ • Installation↓ • User Guide↓
An OpenCode↗ config pack designed for operating long-horizon, multi-task projects.
Models like Opus 4.5 are great for creative work in short back-and-forths; GPT-5.2 excels when left to complete more narrowly-scoped problems. This methodology aims to support the execution of long-running and open-ended projects by using simple mechanisms that resist LLMs' post-training impulses.
$ opencode
█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒
█░ ░▒
█░ Help me set up https://github.com/djgrant/the-scientist ░▒
█░ ░▒
█░ Build Claude Opus 4.5 (latest) Anthropic ░▒
█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒
A baseline set of features are included. These can be used alongside any project and global configs you have already defined. See merging configs↗ and installation↓.
Agents that you interact with directly.
| Agent | Description |
|---|---|
delegate |
Orchestrates long-horizon projects via work packages and subagents |
distill |
Distills analysis by interviewing the user to extract core insights |
Agents that receive delegated tasks.
| Sub-Agent | Description |
|---|---|
architect |
Attempts to keep project entropy low |
critique |
Generates insights through adversarial dialectic |
diverge |
Looks for edge-of-distribution alternatives |
qa |
Performs end-to-end testing to validate/invalidate hypotheses |
ux |
Explores solution with a human-centric perspective |
Slash commands for common workflows.
| Command | Description |
|---|---|
/browser-test |
Test web UI in browser with screenshots |
/files-to-prompt |
Generate a prompt from repo files for use with other AI tools |
/init-scientist |
Initialise project with the-scientist directory structure |
/update-scientist |
Update the-scientist to the latest version |
Lazily-loaded instructions that guide agent behavior.
| Skill | Description |
|---|---|
browser |
Take screenshots and interact with web UIs via Playwright |
divergent-thinking |
Use verbalised sampling to mitigate mode collapse |
orchestrate |
Core methodology for orchestration using sub-agents and work packages |
orchestrate-map-reduce |
Fan out to multiple agents, validate solutions, find a winner |
orchestrate-project |
Define, execute, review, test, and iterate on sub-tasks |
read-learnings |
Review previously recorded project learnings |
record-learnings |
Record notable discoveries for future reference |
scientific-method |
Hypothesis-driven iteration |
simplify |
Find the essence of a solution via iterative simplification |
work-packages |
Structured approach for multi-agent task handoff |
Custom tools available to agents.
| Tool | Description |
|---|---|
files-to-prompt |
Generate prompts from repo files using files-to-prompt |
First, install the config pack globally, then initialise it for each project you want to use it in.
Option 1: As an overlay config
git clone https://github.com/djgrant/the-scientist.git
# Add to your shell profile (.zshrc, .bashrc, etc.)
export OPENCODE_CONFIG_DIR={path_to_cloned_repo}Loads after your global and project settings. See custom directory docs↗.
Options 2: As your global config
git clone https://github.com/djgrant/the-scientist.git ~/.config/opencodeLoads before your project settings. You can alternatively symlink to this location.
Run /init-scientist within your repo. This will set up:
.opencode/work/for work packages.opencode/learnings/for project learnings- Optionally, an AGENTS.md template
For tools that require Python dependencies (browser, files-to-prompt), run /init-agentkit from your global agentkit config.
To update the-scientist to the latest version, you have two options:
1/ Run update command
/update-scientist
The command will instruct the agent to merge any local changes and check for new prerequisites.
2/ Pull Manually
cd {path-to-the-scientist}
git pullThe most important agent in this setup is you.
A clear, well-thought-out vision is to an LLM what a good data structure is to code.
Here are a couple of suggestions you can try as a starting point.
Prompt the delegate agent to:
Commission thorough research looking for gaps and opportunities in this project.
Explore a broad range of areas and ideas.
The delegate agent, using a selection of skills and agents, will ultimately produce an undoubtedly large set of recommendations.
To find the gems in the ruff, switch to the distill agent, and let it prompt you to find out what's worth pursuing.
You can then switch back to the delegate agent and ask it to undertake the work.
For new projects, you can switch the flow around:
- Start opencode in plan mode and explain your vision to the agent
- Leave some questions open (exploration can be delegated to subagents)
- Once the vision is well-formed ask the plan agent to create a "scoping work package" to capture the vision and areas to explore
- Compact the conversation (/compact)
- Switch to delegate mode (tab key), then ask the agent to "read the work package and execute the vision"
The delegate agent will then use subagents to create more detailed work packages, which, in turn, get delegated to other subagents to implement.
I have so far found this setup valuable for:
- Deep-dives e.g find performance/security/ux gaps and opportunities
- Feasibility experiments e.g. build out features to generate insights
- Personal applications e.g. holiday planner, home automation etc.
This system may also be valuable to developers who gain less enjoyment from manually hand-holding agents. Once a long-running project gets started, you get a reasonably long interval to divert your attention toward more focussed tasks.
Whether you decide to ship the code this system produces, or use it as the inspiration for a more-considered build, will depend entirely on your context and risk tolerance.
When you use the delegate agent, orchestrated tasks can run for anything up to an hour (even with agents working in parallel).
It is therefore recommended to be on subscription pricing e.g. Claude Code, Github Copilot etc. (set up via opencode auth login). In my experience, API pricing can end up being a factor of 100x more expensive.
I am personally using this with Opus 4.5. No doubt, Gemini 3, GPT 5.2 and other SOTA-class models will work similarly well. Mixing models will probably boost performance.
I strongly suspect that the system will break down with a model like Sonnet 4.5, and will be no more cost effective.
Note: You can set a default model↗ in your global or project opencode configuration.
It is recommended to add a vision statement to your project's AGENTS.md (agents are instructed to align to this), along with any definitions of what good looks like to you.
MIT License - Copyright (c) 2026 Daniel Grant