# Can Recursive Agents Really Reason Better? We Ran 100 Tasks to Find Out - DSPy x Daytona - Part 1
**作者**: Zachary BENSALEM
**日期**: 2026-05-03T12:54:36.000Z
**来源**: [https://x.com/ZacharyByDesign/status/2050921967667105814](https://x.com/ZacharyByDesign/status/2050921967667105814)
---
> Fleet-RLM is Qredence’s recursive agent runtime, combining @DSPyOSS ReAct agents with @daytonaio -sandboxed execution for tool use, verification, and iteration. All experiments below were run with DeepSeek V4 Flash (via OpenRouter).
What if the key to better AI reasoning isn't a bigger model, but a smarter architecture? We put Fleet-RLM's recursive agent runtime to the test against direct LLM inference on 100 long-horizon reasoning tasks. The results were surprising — and not always in the ways we expected.
- Bottom line up front: Recursive execution more than doubled accuracy (13% → 33%), eliminated all task failures, and revealed a hidden pattern that suggests the real performance gap may be even wider than the scoreboard shows.
Bar chart comparing recursive agents vs. direct LLM inference on long-horizon reasoning tasks, showing a significant accuracy increase and elimination of failures with recursive execution.
## The Problem: Single-Shot Inference Hits a Ceiling
Large language models have gotten remarkably good at many tasks, but long-horizon reasoning remains a stubborn challenge. Ask a model to solve a 20-step BlocksWorld puzzle, optimize a matrix chain multiplication, or convert a complex chess position — and even frontier models start to stumble.
The standard approach is straightforward: prompt the model, get an answer, grade it. This "direct inference" pipeline works well for short-answer questions but struggles with compositional problems that require planning, decomposition, and verification. A single mistake in step 3 cascades through steps 4–20, producing a completely wrong final answer with no chance for recovery.
The question is: can we do better by giving the model a chance to think, verify, and iterate?
## The Benchmark: LongCoT's 100-Task Gauntlet
To find out, we turned to the LongCoT benchmark — a collection of long-horizon reasoning tasks designed to test exactly the kind of multi-step problem-solving that direct inference struggles with.
Our test suite:
- 100 tasks across 5 domains (20 tasks each)
- Domains: Logic (Sudoku, BlocksWorld, Hanoi), Computer Science (matrix chain multiplication, Huffman coding), Chemistry, Chess (UCI-to-FEN, piece combinations), and Math (linear equations, DAGs, backtracking)
- Model: DeepSeek V4 Flash via OpenRouter (125K context, high reasoning effort)
- Evaluation: Native LongCoT scorer, strict format validation
Overview graphic of the 100-task LongCoT benchmark across five domains, illustrating the experimental setup comparing single-shot inference and recursive agent execution.
🧪Experiment schema:
Each task was run once through direct single-shot inference and once through Fleet-RLM, creating a paired comparison across the same 100-task suite.
We ran each task twice: once through direct single-shot inference, and once through Fleet-RLM's recursive agent runtime.
## What Is Recursive Execution?
Before diving into results, let's clarify what "recursive execution" actually means in this context.
Fleet-RLM wraps the LLM in a DSPy ReAct agent that runs inside a Daytona sandbox. Instead of generating an answer in one shot, the agent can:
1. Decompose the problem into subproblems
2. Write and execute Python scripts for exact computation
3. Verify intermediate results before building on them
4. Delegate sub-tasks to child sandboxes with isolated state
5. Iterate when initial attempts fail
Diagram of recursive agent execution workflow, showing problem decomposition, tool use via sandboxed code execution, verification steps, and iterative refinement loops.
Each task gets a budget of up to 20 LLM calls and 20 iterations. The agent receives system tips encouraging decomposition, bounded code execution, and exact answer preservation.
This isn't just chain-of-thought prompting — it's a full reasoning loop with tools, memory, and error recovery.
## 📈 The Results: A 20-Point Accuracy Jump
Recursive execution more than doubled accuracy: Direct inference solved 13/100 tasks, while RLM solved 33/100.
Bar chart showing overall accuracy results: direct inference at 13% versus recursive agent execution at 33%, highlighting a 20-point improvement.
Direct ▓▓▓░░░░░░░ 13%
RLM ▓▓▓▓▓▓▓░░░ 33%
Metric Direct RLM Delta Overall Accuracy 13.00% 33.00% +20.00 pp Correct 13/100 33/100 +20 Incorrect 56/100 67/100 +11 Failed 31/100 0/100 −31
Comparison of failure rates between methods, with direct inference failing on 31% of tasks and recursive execution achieving zero failures.
The headline is clear: recursive execution more than doubles accuracy. But the real story is in the details.
## The Failure Elimination
Direct mode failed on 31% of tasks — mostly timeouts, crashes, or completely unparseable outputs. RLM eliminated every single failure. The recursive runtime's retry logic, sandbox isolation, and structured output handling turned potentially fatal errors into recoverable iterations.
Comparison of failure rates between methods, with direct inference failing on 31% of tasks and recursive execution achieving zero failures.
✅
Failure rate: Direct mode failed on 31% of tasks. RLM failed on 0%.
Direct failures ███████████████████████████████ 31
RLM failures 0
This alone is significant: if you're building a production system, zero failures vs. 31% failures is the difference between "works sometimes" and "works reliably."
## The Per-Domain Breakdown
Not all domains responded equally to recursive execution:
Per-domain performance comparison showing large gains in logic, computer science, and chess tasks with recursive agents, flat results in math, and decline in chemistry.
```
Logic Direct 10% ██░░░░░░░░ RLM 80% ████████░░ +70 pp
CS Direct 5% █░░░░░░░░░ RLM 35% ████░░░░░░ +30 pp
Chess Direct 10% ██░░░░░░░░ RLM 40% ████░░░░░░ +30 pp
Math Direct 10% ██░░░░░░░░ RLM 10% ██░░░░░░░░ 0 pp
Chemistry Direct 30% ███░░░░░░░ RLM 0% ░░░░░░░░░░ −30 pp
```
- Logic was the star performer. RLM achieved 80% accuracy — an 8× improvement. Structured puzzles like Sudoku, BlocksWorld, and Tower of Hanoi are perfect matches for the recursive approach: decompose into moves, simulate each step, verify constraints, and backtrack when needed.
- CS and Chess both saw solid +30 pp gains. Algorithmic problems and board-state manipulations benefit from the agent's ability to write exact computation scripts rather than reasoning purely in natural language.
- Math was flat at 10% for both modes. Despite the agent's coding ability, mathematical reasoning tasks (linear equations, DAG problems, conditional logic) remained stubbornly difficult. We'll return to why.
- Chemistry was the outlier — the only domain where RLM underperformed. Direct mode scored 30%; RLM scored 0%. This wasn't a random fluke; it reveals an important limitation of the recursive approach.
## The Hidden Pattern: Format vs. Reasoning
Here's where things get really interesting.
The LongCoT evaluator classifies answers as correct, incorrect, or failed. Within "incorrect," it further distinguishes wrong formatting from substantively wrong answers. We expected RLM to produce more incorrect-but-reasoned answers. What we found was stranger.
⚠️Hidden scoring issue: RLM's incorrect answers were 100% formatting errors, suggesting the measured score may understate the reasoning quality.
Breakdown of incorrect answers revealing that all recursive agent errors were due to formatting issues, while direct inference errors were mostly substantive reasoning failures.
Direct incorrect answers: 56 total | 13 formatting | 43 substantive / mixed
RLM incorrect answers: 67 total | 67 formatting | 0 substantive validated wrong
- Every single RLM incorrect answer was a formatting error.
Not one RLM incorrect answer was substantively wrong in a way that passed format validation. The agent produced reasoning, code, partial solutions — but the final solution = [...] line didn't exactly match the expected schema. In direct mode, by contrast, 43 of 56 incorrect answers were both substantively wrong and badly formatted.
- What this means: RLM is solving the underlying reasoning problem correctly far more often than the 33% score suggests. The bottleneck isn't reasoning quality — it's answer formatting. A more forgiving extractor or a post-hoc format repair step could potentially unlock significantly higher accuracy.
This is both a limitation and an opportunity. The recursive agent is doing the hard part (reasoning) well; it's tripping on the easy part (output formatting).
## Why Chemistry Broke the Pattern
Chemistry was the only domain where RLM failed completely (0% vs. direct's 30%). Why?
The recursive agent's strengths — code execution, decomposition, simulation — are poorly matched to chemistry problems, which often rely on:
- Domain knowledge (molecular structures, reaction mechanisms)
- Conceptual reasoning rather than algorithmic computation
- Answers that don't fit the solution = [...] code-friendly format
While the agent excels at "write a Python script to simulate this," chemistry tasks ask "what happens when these reagents mix?" The sandbox environment is optimized for computation, not for retrieving or reasoning over chemical knowledge bases.
This isn't a failure of recursive execution per se — it's a domain mismatch. The lesson: recursive agents shine where problems decompose into computable subproblems. They struggle where domain expertise and conceptual reasoning dominate.
## The Cost of Recursion
Better results come with a price. Each RLM task consumed 5–20 LLM API calls (vs. 1 for direct mode), and the first full benchmark attempt was interrupted at task 36 when OpenRouter credits ran out.
Cost profile: Direct inference uses 1 LLM call per task. RLM uses roughly 5–20 LLM calls, so it should be reserved for tasks where decomposition and verification justify the cost.
For production use, this means:
- Budget accordingly: RLM runs cost roughly 5–20× more in API tokens than direct inference
- Plan for retries: The 100% transport success rate means you get an answer for every dollar spent — but you spend more dollars
- Target the right problems: The +70 pp gain in logic justifies the cost; the 0% in chemistry doesn't
## What This Means for Practitioners
If you're building with LLMs, here are three actionable takeaways:
1. Use recursive execution for structured, decomposable problems. Logic puzzles, algorithmic tasks, code generation, and anything that benefits from step-by-step verification are prime candidates. The gains are substantial and consistent.
2. Don't assume bigger models fix reasoning. Our model (DeepSeek V4 Flash) is capable but not the absolute frontier. The architecture change (recursive execution) produced far larger gains than simply scaling up would have.
3. Invest in answer extraction robustness. The 100% formatting-error rate suggests RLM's reasoning is stronger than its score. A better post-processor — one that can extract answers from verbose outputs, repair formatting, or validate schema compliance — could unlock the next 10–20 percentage points.
## Limitations and Future Work
This benchmark has important caveats:
- Single model: We tested only DeepSeek V4 Flash. Results may vary with other models.
- Single benchmark: LongCoT is one of many reasoning benchmarks. Cross-benchmark validation is needed.
- Format sensitivity: The strict solution = [...] requirement may undercount RLM's true reasoning ability.
- Chemistry gap: More work is needed to understand why RLM fails in knowledge-heavy domains and whether hybrid approaches (retrieval + code) can help.
## Conclusion
Recursive agent execution isn't a silver bullet — but for the right problems, it's a dramatic improvement over direct inference. Our 100-task benchmark shows a +20 percentage point overall accuracy gain, zero failures, and a hidden pattern suggesting the real reasoning gap may be even wider.
The results also highlight a clear boundary: recursive agents excel where problems decompose into code and verification steps, and struggle where domain knowledge and conceptual reasoning dominate.
For teams building AI systems that need reliable reasoning, the message is clear: don't just buy a bigger model. Give it a chance to think.
## Resources
- Qredence : @AgenticFleet https://qredence.ai
- Fleet-RLM: github.com/qredence/fleet-rlm
- Community : https://discord.gg/gjr2MH32fv
- Benchmark : LongCot Mini : https://github.com/LongHorizonReasoning/longcot
- Benchmark code: scripts/run_longcot_eval.py
- Summary results: output/longcot-eval/comparison-report-20260501_023606.md
- Comprehensive analysis: output/longcot-eval/COMPREHENSIVE_COMPARISON_REPORT.md — full per-task breakdown, domain analysis, formatting anomaly deep-dive, and recommendations
- Model: DeepSeek V4 Flash via OpenRouter
- Run on May 1, 2026. 100 tasks, 5 domains, 2 execution modes
## 相关链接
- [Zachary BENSALEM](https://x.com/ZacharyByDesign)
- [@ZacharyByDesign](https://x.com/ZacharyByDesign)
- [19K](https://x.com/ZacharyByDesign/status/2050921967667105814/analytics)
- [@DSPyOSS](https://x.com/@DSPyOSS)
- [@daytonaio](https://x.com/@daytonaio)
- [@AgenticFleet](https://x.com/@AgenticFleet)
- [https://qredence.ai](https://qredence.ai/)
- [github.com/qredence/fleet-rlm](http://github.com/qredence/fleet-rlm)
- [https://discord.gg/gjr2MH32fv](https://discord.gg/gjr2MH32fv)
- [https://github.com/LongHorizonReasoning/longcot](https://github.com/LongHorizonReasoning/longcot)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [8:54 PM · May 3, 2026](https://x.com/ZacharyByDesign/status/2050921967667105814)
- [19.5K Views](https://x.com/ZacharyByDesign/status/2050921967667105814/analytics)
- [View quotes](https://x.com/ZacharyByDesign/status/2050921967667105814/quotes)
---
*导出时间: 2026/5/4 09:22:35*
---
## 中文翻译
# 递归代理真的能更好地推理吗？我们运行了 100 项任务来寻找答案 - DSPy x Daytona - 第一部分
**作者**: Zachary BENSALEM
**日期**: 2026-05-03T12:54:36.000Z
**来源**: [https://x.com/ZacharyByDesign/status/2050921967667105814](https://x.com/ZacharyByDesign/status/2050921967667105814)
---
> Fleet-RLM 是 Qredence 的递归代理运行时，它结合了 @DSPyOSS ReAct 代理和 @daytonaio 沙盒执行环境，用于工具使用、验证和迭代。以下所有实验均使用 DeepSeek V4 Flash（通过 OpenRouter）运行。
如果获得更好 AI 推理能力的关键不是更大的模型，而是更智能的架构会怎么样？我们在 100 项长视界推理任务上对 Fleet-RLM 的递归代理运行时与直接 LLM 推理进行了对比测试。结果令人惊讶——而且并不总是以我们预期的方式。
- 结论先行：递归执行的准确率翻了一倍多（13% → 33%），消除了所有任务失败，并揭示了一个隐藏模式，表明实际的性能差距可能比记分板显示的还要大。
比较递归代理与直接 LLM 推理在长视界推理任务上的表现的条形图，显示递归执行显著提高了准确率并消除了失败情况。
## 问题：单次推理遭遇瓶颈
大型语言模型在许多任务上已经表现得非常出色，但长视界推理仍然是一个顽固的挑战。让模型解决一个 20 步的积木世界谜题，优化矩阵链乘法，或转换一个复杂的国际象棋局面——即使是前沿模型也会开始跌跌撞撞。
标准方法很简单：提示模型，获得答案，进行评分。这种“直接推理”流程对短答案问题很有效，但在需要规划、分解和验证的组合性问题上举步维艰。第 3 步的一个小错误会波及第 4 到 20 步，导致最终答案完全错误，且没有补救的机会。
问题是：我们能否通过给模型思考、验证和迭代的机会做得更好？
## 基准测试：LongCoT 的 100 项任务挑战
为了找到答案，我们使用了 LongCoT 基准测试——这是一系列长视界推理任务，专门旨在测试直接推理所困扰的那种多步问题解决能力。
我们的测试套件：
- 跨 5 个领域的 100 项任务（每个领域 20 项）
- 领域：逻辑（数独、积木世界、汉诺塔）、计算机科学（矩阵链乘法、霍夫曼编码）、化学、国际象棋（UCI 转 FEN、棋子组合）和数学（线性方程、有向无环图、回溯）
- 模型：通过 OpenRouter 的 DeepSeek V4 Flash（125K 上下文，高推理强度）
- 评估：原生 LongCoT 评分器，严格的格式验证
跨越五个领域的 100 项任务 LongCoT 基准测试概览图，说明了比较单次推理和递归代理执行的实验设置。
🧪实验方案：
每项任务通过直接单次推理运行一次，并通过 Fleet-RLM 运行一次，从而在相同的 100 项任务套件上创建配对比较。
我们每项任务运行两次：一次通过直接单次推理，一次通过 Fleet-RLM 的递归代理运行时。
## 什么是递归执行？
在深入结果之前，让我们澄清一下“递归执行”在这个语境下的实际含义。
Fleet-RLM 将 LLM 封装在一个在 Daytona 沙盒中运行的 DSPy ReAct 代理中。代理不是一次性生成答案，而是可以：
1. 将问题分解为子问题
2. 编写并执行 Python 脚本进行精确计算
3. 在建立后续步骤之前验证中间结果
4. 将子任务委托给具有隔离状态的子沙盒
5. 在初次尝试失败时进行迭代
递归代理执行工作流程图，展示了问题分解、通过沙盒代码执行进行的工具使用、验证步骤和迭代优化循环。
每个任务最多有 20 次 LLM 调用和 20 次迭代的预算。代理会收到系统提示，鼓励进行分解、有界代码执行和精确答案保留。
这不仅仅是思维链提示——这是一个包含工具、记忆和错误恢复的完整推理循环。
## 📈 结果：准确率跃升 20 个百分点
递归执行的准确率翻了一倍多：直接推理解决了 13/100 项任务，而 RLM 解决了 33/100 项。
显示总体准确率结果的条形图：直接推理为 13%，递归代理执行为 33%，突出了 20 个百分点的提升。
Direct ▓▓▓░░░░░░░ 13%
RLM ▓▓▓▓▓▓▓░░░ 33%
Metric Direct RLM Delta Overall Accuracy 13.00% 33.00% +20.00 pp Correct 13/100 33/100 +20 Incorrect 56/100 67/100 +11 Failed 31/100 0/100 −31
两种方法之间的失败率比较，直接推理在 31% 的任务上失败，而递归执行实现了零失败。
标题很明确：递归执行的准确率翻了一倍多。但真正的故事在于细节。
## 消除失败
直接模式在 31% 的任务上失败了——主要是超时、崩溃或完全无法解析的输出。RLM 消除了每一个失败。递归运行时的重试逻辑、沙盒隔离和结构化输出处理将潜在的致命错误变成了可恢复的迭代。
两种方法之间的失败率比较，直接推理在 31% 的任务上失败，而递归执行实现了零失败。
✅
失败率：直接模式在 31% 的任务上失败。RLM 失败率为 0%。
Direct failures ███████████████████████████████ 31
RLM failures 0
仅此一点就意义重大：如果你正在构建一个生产系统，零失败率与 31% 的失败率之间的区别就是“偶尔能用”和“可靠工作”的区别。
## 分领域细分
并非所有领域对递归执行的响应都相同：
分领域性能比较显示，递归代理在逻辑、计算机科学和国际象棋任务上获得了巨大收益，数学结果持平，化学方面有所下降。
```
Logic Direct 10% ██░░░░░░░░ RLM 80% ████████░░ +70 pp
CS Direct 5% █░░░░░░░░░ RLM 35% ████░░░░░░ +30 pp
Chess Direct 10% ██░░░░░░░░ RLM 40% ████░░░░░░ +30 pp
Math Direct 10% ██░░░░░░░░ RLM 10% ██░░░░░░░░ 0 pp
Chemistry Direct 30% ███░░░░░░░ RLM 0% ░░░░░░░░░░ −30 pp
```
- 逻辑表现最为抢眼。RLM 达到了 80% 的准确率——提高了 8 倍。像数独、积木世界和汉诺塔这样的结构化谜题与递归方法完美匹配：分解为移动步骤，模拟每一步，验证约束，并在需要时回溯。
- 计算机科学和国际象棋都实现了坚实的 +30 个百分点的增长。算法问题和棋局状态操作受益于代理编写精确计算脚本的能力，而不是纯粹用自然语言推理。
- 数学在两种模式下都持平在 10%。尽管代理具有编码能力，但数学推理任务（线性方程、DAG 问题、条件逻辑）仍然极其困难。我们稍后会探讨原因。
- 化学是个例外——这是 RLM 表现不佳的唯一领域。直接模式得分为 30%；RLM 得分为 0%。这并不是随机偶然；它揭示了递归方法的一个重要局限性。
## 隐藏的模式：格式 vs. 推理
这里事情变得非常有趣。
LongCoT 评估器将答案分类为正确、错误或失败。在“错误”中，它进一步区分格式错误和实质性错误答案。我们预计 RLM 会产生更多错误但有推理的答案。我们发现的情况更奇怪。
⚠️隐藏的评分问题：RLM 的错误答案 100% 是格式错误，这表明测量分数可能低估了推理质量。
错误答案的细分显示，所有递归代理错误都是由于格式问题，而直接推理错误主要是实质性推理失败。
Direct incorrect answers: 56 total | 13 formatting | 43 substantive / mixed
RLM incorrect answers: 67 total | 67 formatting | 0 substantive validated wrong
- 每一个 RLM 错误答案都是格式错误。
没有一个 RLM 错误答案在通过格式验证的方式上是实质性错误的。代理产生了推理、代码、部分解决方案——但最终的 solution = [...] 行与预期的模式不完全匹配。相比之下，在直接模式下，56 个错误答案中有 43 个既是实质性错误又是格式糟糕。
- 这意味着：RLM 正确解决潜在推理问题的频率远高于 33% 的分数所暗示的。瓶颈不在于推理质量——而在于答案格式。一个更宽容的提取器或事后格式修复步骤可能会释放显著更高的准确率。
这既是一个限制，也是一个机会。递归代理很好地完成了困难的部分（推理）；它在容易的部分（输出格式）上跌倒了。
## 为什么化学打破了模式
化学是 RLM 完全失败的唯一领域（0% vs. 直接模式的 30%）。为什么？
递归代理的优势——代码执行、分解、模拟——与化学问题匹配度很低，因为化学问题通常依赖于：
- 领域知识（分子结构、反应机制）
- 概念推理而非算法计算
- 不符合 solution = [...] 代码友好格式的答案
虽然代理擅长“编写一个 Python 脚本来模拟这个”，但化学任务问的是“当这些试剂混合时会发生什么？”沙盒环境是针对计算优化的，而不是针对检索或推理化学知识库。
这并不是递归执行本身的失败——而是领域不匹配。教训是：递归代理在问题可以分解为可计算子问题的地方表现出色。在领域专业知识和概念推理占主导地位的地方，它们会感到吃力。
## 递归的代价
更好的结果是有代价的。每项 RLM 任务消耗 5–20 次 LLM API 调用（直接模式为 1 次），第一次完整的基准测试尝试在任务 36 时中断，因为 OpenRouter 积分用完了。
成本概况：直接推理每项任务使用 1 次 LLM 调用。RLM 大约使用 5–20 次 LLM 调用，因此它应该保留给分解和验证证明其成本合理的任务。
对于生产使用，这意味着：
- 相应地预算：RLM 运行的成本大约是直接推理的 5–20 倍（以 API 令牌计）
- 计划重试：100% 的传输成功率意味着你花的每一美元都能得到一个答案——但你花的美元更多
- 针对正确的问题：逻辑方面 +70 个百分点的收益证明了成本的合理性；化学方面的 0% 则不然
## 这对从业者意味着什么
如果你正在使用 LLM 构建，这里有三个可操作的要点：
1. 对结构化的、可分解的问题使用递归执行。逻辑谜题、算法任务、代码生成以及任何受益于逐步验证的事情都是主要候选者。收益是巨大且一致的。
2. 不要假设更大的模型能修复推理。我们的模型（DeepSeek V4 Flash）很有能力，但不是绝对的尖端。架构变更（递归执行）产生的收益远比单纯的规模扩大要大。
3. 投资于答案提取的鲁棒性。100% 的格式错误率表明 RLM 的推理强于其分数。一个更好的后处理器——能够从冗长的输出中提取答案、修复格式或验证模式合规性——可以释放下一个 10–20 个百分点。
## 局限性和未来工作
这个基准测试有重要的注意事项：
- 单一模型：我们只测试了 DeepSeek V4 Flash。其他模型的结果可能有所不同。
- 单一基准：LongCoT 只是众多推理基准之一。需要跨基准验证。
- 格式敏感性：严格的 solution = [...] 要求可能会低估 RLM 的真实推理能力。
- 化学差距：需要更多工作来理解为什么 RLM 在知识密集型领域失败，以及混合方法（检索 + 代码）是否有帮助。
## 结论
递归代理执行不是灵丹妙药——但对于正确的问题，它比直接推理有了巨大的改进。我们的 100 项任务基准测试显示总体准确率提高了 +20 个百分点，零失败，以及一个隐藏模式，表明实际推理差距可能更大。
结果也凸显了一个明显的界限：递归代理在问题可以分解为代码和验证步骤的地方表现出色，而在领域知识和概念推理占主导地位的地方感到吃力。
对于需要可靠推理的 AI 系统构建团队，信息很明确：不要只买更大的模型。给它一个思考的机会。
## 资源
- Qredence : @AgenticFleet https://qredence.ai
- Fleet-RLM: github.com/qredence/fleet-rlm
- 社区 : https://discord.gg/gjr2MH32fv
- 基准测试 : LongCot Mini : https://github.com/LongHorizonReasoning/longcot
- 基准测试代码: scripts/run_longcot_eval.py
- 总结结果: output/longcot-eval/comparison-report-20260501_023606.md
- 综合分析: output/longcot-eval/COMPREHENSIVE_COMPARISON_REPORT.md — 完整的每项任务细分、领域分析、格式异常深度分析和建议
- 模型: DeepSeek V4 Flash via OpenRouter
- 运行于 2026 年 5 月 1 日。100 项任务，5 个领域，2 种执行模式
## 相关链接
- [Zachary BENSALEM](https://x.com/ZacharyByDesign)
- [@ZacharyByDesign](https://x.com/ZacharyByDesign)
- [19K](https://x.com/ZacharyByDesign/status/2050921967667105814/analytics)
- [@DSPyOSS](https://x.com/@DSPyOSS)
- [@daytonaio](https://x.com/@daytonaio)
- [@AgenticFleet](https://x.com/@AgenticFleet)
- [https://qredence.ai](https://qredence.ai/)
- [github.com/qredence/fleet-rlm](http://github.com/qredence/fleet-rlm)
- [https://discord.gg/gjr2MH32fv](https://discord.gg/gjr2MH32fv)
- [https://github.com/LongHorizonReasoning/longcot](https://github.com/LongHorizonReasoning/longcot)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [8:54 PM · May 3, 2026](https://x.com/ZacharyByDesign/status/2050921967667105814)
- [19.5K Views](https://x.com/ZacharyByDesign/status/2050921967667105814/analytics)
- [View quotes](https://x.com/ZacharyByDesign/status/2050921967667105814/quotes)
---
*导出时间: 2026/5/4 09:22:35*