DAEDALUS bootstraps agent memory from self-generated tasks — no curated tasks, no oracle verifier
Illuin's explorer–solver loop keeps a heuristic only after it turns a failure into repeated success: up to +15.9 points on AppWorld, τ²-bench, and AutomationBench
Illuin Technology released a preprint for DAEDALUS, a training-free method that bootstraps a reusable memory bank of textual heuristics from self-generated practice tasks — no curated task set, no oracle verifier. Across AppWorld, τ²-bench, and AutomationBench, the paper reports up to 15.9 points higher mean success rate and 1.7–2.2× pass^5 over a no-memory baseline, beating the closest prior method and matching approaches that train on the benchmarks' own tasks.
What shipped
Agents dropped into a new environment lack operational knowledge — tool quirks, environment conventions — and without memory they rediscover it task by task, repeating the same mistakes. Existing memory methods (ExpeL, AutoGuide, reflection-based systems) typically build memory from a curated set of training tasks, often paired with an oracle verifier that scores each attempt. That supervision requires prior knowledge of the environment and real human effort — exactly what a new environment lacks.
DAEDALUS replaces it with a one-time budget of n practice sessions, each running two nested loops:
- Outer loop — Explorer. Proposes a task (instruction plus explicit success conditions) and adjusts difficulty based on inner-loop feedback.
- Inner solver loop. A Solver attempts the task from a freshly reset environment. An LLM Judge checks the trajectory against the success conditions. On failure, an Extractor writes or revises a heuristic from the instruction and the failed trajectory. The Extractor is deliberately blinded to which success conditions were missed, pushing heuristics toward generalizable guidance instead of task-specific patches.
The loop stops when the Solver succeeds N_s consecutive times or fails N_f times in total. The released defaults are N_s = 3, N_f = 8, and 40 explorer turns per session. Three outcomes:
- Accepted — the Solver failed at least once, then hit the success streak with the heuristic in context. The heuristic enters the bank.
- Too easy — the Solver never failed, so there is no learning signal.
- Too hard — the Solver hit N_f failures. Difficulty feedback goes back to the Explorer, and refinements are condensed into task-design guidelines for later sessions.
The core design choice: heuristics are validated by whether they fix the failure they came from, not by the outcome of the originating trajectory. Prior methods keep an insight because the trajectory it was drawn from succeeded or failed; DAEDALUS keeps one only after it demonstrably converts a failure into repeated success. Requiring a streak rather than a single success lowers the odds of accepting an ineffective heuristic by chance.
A Surveyor agent analyzes the environment with coverage tags; accepted heuristics are consolidated into a memory bank injected whole into context at the start of each test-time task.
All results below are self-reported in the preprint:
- Up to +15.9 points mean success rate and 1.7–2.2× pass^5 (the share of tasks solved in all five runs) over a no-memory baseline across the three benchmarks.
- Beats PREPING, the closest prior work, which also builds memory from self-proposed tasks but validates by task feasibility and completion scores rather than by testing the heuristic itself.
- Competitive with methods that use the benchmark training tasks, at little to no extra inference cost.
- Cross-model transfer: gains hold across model families, including when memory is generated with one family and used by another.
- Per-model gains on AppWorld test_normal (Figure 1): gpt-5.4-mini +16.0, gpt-5.4-nano +26.3, deepseek-v4-flash-0731 +8.3, minimax-m2.7 +18.7, nemotron-3.5-lightning +7.7, qwen3.6-35b-a3b +16.1, glm-5.3-flash +1.7 points — seven models from six families, all also completing tasks in fewer turns.
- Ablations: solver traces are the key signal for deriving effective heuristics; memory drawn from exploration alone hurts the agent; factorizing early discoveries makes exploration more cost-efficient; and consolidating the bank and injecting it whole at the start of each task outperforms per-turn retrieval — "at this scale".
- Evaluation proxy: the self-generated tasks rank models consistently with the official benchmark test sets, suggesting they could stand in for a curated benchmark when none exists.
Why it matters
For environments with no existing benchmark or task set, these results are directly useful.
The validation loop needs no new model architecture. The explorer–solver–extractor pattern is a harness change: any environment with a resettable state and a judge can run it, and the memory it produces is plain text injected into context — no weight updates.
The "test the memory before you keep it" principle is the actual contribution. It is a cheap, general fix for the failure mode of reflection-based memory: an insight that sounds plausible but does not change behavior. Requiring N_s consecutive successes is a concrete, tunable acceptance test.
The whole-bank-injection result is a useful counterpoint to the default assumption that memory needs retrieval infrastructure. At the bank sizes in this paper, stuffing the entire bank into the prompt at task start beat per-turn retrieval — worth benchmarking before you build a vector store.
Caveats
- This is a one-day-old preprint with no independent replication; every number above is the authors' own report.
- The code is MIT-licensed at github.com/illuin-tech/daedalus; all artifacts — tasks, heuristic banks, sessions, and every agent trajectory — are on HuggingFace as illuin/daedalus-traces. AppWorld-derived outputs are encrypted (AES-256) because AppWorld's licence requires it.
- Reported costs price every call at OpenAI standard-tier rates and assume each conversation's earlier prompt is fully cached; your real costs depend on model choice and cache hit rate.
- The oracle verifier is replaced by an LLM Judge. The paper measures the Judge's agreement with official benchmark verifiers (Section 5.1), but the judge's reliability is the natural thing to scrutinize: if it agrees imperfectly with ground truth, accepted heuristics can encode judge errors.
- The "whole bank beats retrieval" finding carries an explicit "at this scale" qualifier; it may not survive as the bank grows past context limits.
- The headline "up to 15.9 points" is the largest gain reported across the three benchmarks; the per-benchmark tables live in the paper's results section.