SkyworkAI/DeepResearchAgent: A Self-Evolution Runtime for LLM Agents
DeepResearchAgent is a hierarchical multi-agent system designed not only for deep research tasks but also for general-purpose task solving. The framework leverages a top-level planning agent to coordinate multiple specialized lower-level agents, enabling automated task decomposition and efficient execution across diverse and complex domains.
At a glance
- What is it?
- DeepResearchAgent pairs a resource protocol layer with a self-evolution operator loop, so prompts, agents, tools and memory become versioned, rollback-capable resources. It is a framework for engineers building long-running agent systems, not a hosted research product.
- Who is it for?
- Adopt DeepResearchAgent if you need auditable, versioned evolution of prompts and agents and you are willing to supply your own model keys and read the config system carefully. Skip it if you want a hosted research assistant, a Gemini Deep Research replacement, or a small dependency footprint: requirements.txt pulls in torch, trading SDKs, browser and mobile libraries, and the README does not document rollback recovery or a stable API surface.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 150 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 1, 2026, and from our analysis. They are not legal advice.
Editorial analysis
What DeepResearchAgent solves, and who it is actually for
Most agent stacks treat prompts, tools and memory as code that gets edited in place. There is no state machine around them, no version history, and no defined way to undo a change that made the agent worse. The README states this directly: existing protocols "under-specify cross-entity lifecycle/context management, version tracking, and safe evolution update interfaces," which produces monolithic compositions and brittle glue code.
DeepResearchAgent is aimed at the engineer who has already built one agent loop and now needs to change it repeatedly without losing track of which prompt version produced which trace. The repository is a Python framework, MIT licensed, with a planner coordinating specialised lower-level agents, plus a separate self-evolution layer. It is not a product you point at a question. The homepage exists, but the README describes a runtime you compose from configs, not a hosted service.
The two protocol layers are the core claim. RSPL models prompts, agents, tools, environments and memory as protocol-registered resources with explicit state, lifecycle and versioned interfaces. SEPL defines a closed-loop operator interface to propose, assess and commit improvements with auditable lineage and rollback. If you only need a single agent calling a search tool, this is more machinery than the problem requires.
How the RSPL and SEPL layers fit together
The repository layout makes the separation concrete. src/agent/ holds runtime logic that decides what to do next. src/tool/ holds callable capabilities. src/environment/ holds stateful interfaces such as filesystem, browser, mobile and trading backtest environments. src/memory/ holds session and event memory. src/optimizer/ holds the self-improvement algorithms, named in the README as reflection, GRPO and Reinforce++. src/tracer/ and src/version/ record trajectories and manage iterative artifacts across runs.
The loop the README describes has four steps: Act, Observe, Optimize, Remember. An agent produces actions using an LLM and available tools. Outcomes, traces and environment feedback are captured. An optimizer updates prompts, solutions or variables. Summaries and insights are persisted to memory for later steps and sessions. The versioning layer is what makes the Optimize step reversible rather than destructive.
Configs are MMEngine-style and live in configs/, with src/config/ handling composition of agents, tools, environments, memory and models. That is the integration point: you assemble a run by composing config files rather than editing agent source. The trade-off is real. MMEngine-style config composition is powerful and also a second language to learn, and the README does not document a schema reference for it.
Installing DeepResearchAgent and running the tool-calling agent
The README lists prerequisites rather than a full install procedure: install dependencies in your environment, then copy .env.template to .env and set a model API key. The repository ships environment.yml alongside requirements.txt, and requirements.txt is long, covering LangChain, LangGraph, MMEngine, multiple LLM providers, search engines, trading SDKs, torch and mobile tooling. Expect a heavy environment; the README does not offer a minimal install profile.
Start by creating the environment file and filling in a key. The README gives OPENROUTER_API_KEY as the example:
cp .env.template .env
# then edit .env and set OPENROUTER_API_KEY=...With the key in place, the documented entry point is the tool-calling agent example:
python examples/run_tool_calling_agent.py --config configs/tool_calling_agent.pyThe README also shows how to override the model and output directory through --cfg-options, which is the pattern you will use for every experiment:
python examples/run_tool_calling_agent.py \
--config configs/tool_calling_agent.py \
--cfg-options model_name=openrouter/gpt-4o workdir=workdir/demo tag=demoRuntime artifacts land under workdir/, which the repository layout describes as holding logs, traces, results and similar output. The README does not state what a successful run prints, so treat the trace files as the thing to inspect rather than console output. The examples/ directory is where the breadth lives: run_benchmark.py, run_esg_agent.py, run_leetcode_agent.py, run_interday_trading.py, run_aime_reflection_experiment.py and others. Those filenames are the closest thing to a feature index the repository offers.
Where the framework gets in your way
The dependency list is the first limitation. requirements.txt includes torch, torchvision, torchaudio, transformers pinned at 4.36.2, FAISS, scrapy, alpaca-py, binance SDKs, tushare, akshare, hyperliquid-python-sdk, adbutils, cairosvg, streamlit and flask. A research-agent deployment that only needs search and summarisation still inherits that surface if you install the file as written. The README does not describe optional extras or a slim install, so dependency isolation is on you.
Second, the self-evolution claim is the part with the least operational documentation. The README states that SEPL supports rollback and auditable lineage, but it does not document how a rollback is triggered, what happens to in-flight runs, or how lineage is queried. If your reason for adopting this project is the evolution loop, that is the gap to probe in src/optimizer/ and src/version/ before you commit.
Third, scope. The repository mixes deep research, trading backtests, mobile agents, LeetCode solving and benchmark harnesses. That breadth is a sign of an internal research codebase released as a framework. It also means interfaces that suit one domain may not suit yours, and the README does not promise API stability across the two tagged releases, v1.0.0 and v2.0.0.
Finally, the repository is not archived, but the last push was on 2026-05-04, so it is not being updated continuously.
DeepResearchAgent versus LangChain and LangGraph alone
The honest alternative is the stack DeepResearchAgent already depends on: LangChain for tool and model abstractions, LangGraph for graph-shaped agent control flow. requirements.txt pins langchain>=0.3.75 and langgraph>=0.0.20, so you can build a multi-agent researcher on those two directly.
The difference in approach is what sits above them. LangGraph gives you explicit state and cycles; it does not give you a resource registry where a prompt is a versioned object with a lifecycle, and it does not ship an optimizer layer that proposes and commits changes to that prompt. DeepResearchAgent's RSPL and SEPL are that layer. If your team already versions prompts in git and reviews changes by pull request, you may be duplicating that with a heavier runtime.
The other comparison worth drawing is against hosted deep research products. Those answer a question and return a report. DeepResearchAgent is the opposite shape: a runtime you configure, with agents, tools, environments, memory and optimizers as composable parts. Choosing between them is a build-versus-buy decision, not a feature comparison.
Licence, maintenance and upgrade cost
The repository is MIT licensed, which permits commercial use and modification with the licence and copyright notice retained. That is a permissive starting point, but it says nothing about the licences of vendored code: the layout includes a libs/ directory described as vendored libraries and a .gitmodules file, meaning some code arrives as submodules with their own terms. Check libs/ and .gitmodules before shipping. Nothing here is legal advice.
Upgrade cost is driven by two things. The first is the config system: MMEngine-style composition means a breaking change in a config key propagates to every config under configs/ that you maintain. The second is the dependency pins. transformers is pinned exactly at 4.36.2, and the file mixes loosely bounded packages with exact pins, so resolving a conflict with your own stack may force edits to requirements.txt. The README does not document a versioning or deprecation policy for configs.
On maintenance: the repository is not archived, and the last push was on 2026-05-04. The two releases, v1.0.0 and v2.0.0, are both tagged 2026-02-24, with v2.0.0 labelled "self evoving" and v1.0.0 labelled "pre version". There is no published cadence beyond that.
Editorial conclusion
Adopt DeepResearchAgent if you need auditable, versioned evolution of prompts and agents and you are willing to supply your own model keys and read the config system carefully. Skip it if you want a hosted research assistant, a Gemini Deep Research replacement, or a small dependency footprint: requirements.txt pulls in torch, trading SDKs, browser and mobile libraries, and the README does not document rollback recovery or a stable API surface. Before committing, verify three things in the repository: that a config under configs/ matches your provider, that .env.template lists the key name your backend expects, and that the examples/ script closest to your use case actually runs in your environment.
Frequently asked questions
What are Deep Research agents?
In this project, a deep research agent is a tool-calling agent built on the DeepResearchAgent runtime that can dynamically instantiate, retrieve and refine resources and improve during execution. A top-level planning agent coordinates specialised lower-level agents for task decomposition.
Can I use DeepSearch for free?
The code is MIT licensed, so the framework itself carries no licence fee. You still need model API credentials: the README tells you to copy .env.template to .env and set a key such as OPENROUTER_API_KEY, and those providers bill separately.
How do I build a Deep Research agent?
Compose a run from configs under configs/, set a model API key in .env, and start from an example such as examples/run_tool_calling_agent.py with --config configs/tool_calling_agent.py. The README describes adding or replacing agents, tools, environments, memory systems and optimizers without rewriting the stack.
How do I use the Gemini Deep Research agent?
DeepResearchAgent is not the Gemini product; it is a runtime you install and configure. It does list langchain_google_genai among its dependencies and supports multiple providers, but the README does not document a Gemini-specific setup beyond the provider packages in requirements.txt.
What is a deep research agent?
The README describes it as a self-evolution protocol and runtime for LLM-based agent systems, with agents, tools, environments, memory and optimizers as protocol-registered resources. The Act, Observe, Optimize, Remember loop is the mechanism it uses to refine results across steps and sessions.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/skyworkai-deepresearchagent)