Show HN:用 Rust 和 Bevy 构建的自动运行太空经济模拟游戏

Hacker News Top 产品

摘要

一款用 Rust 和 Bevy 构建的自动运行太空经济模拟器,具备自主代理、动态市场和完整模拟功能,现已以 MIT 许可证开源。

<p>我用 Claude 构建了这个项目,因为我一直想摆弄模拟经济,并且我喜欢太空主题。</p><p>这是一个没有任何脚本的太空经济模拟。数百艘自主飞船各自运行自己的规划器。有些追寻最佳贸易路线,接受送货合同,加油,在造船厂改装,或者停靠以便船员在士气低落前休息。</p><p>市场根据供应情况定价,并采用短缺紧急倍数,派系征税和补贴,人口在不满意时迁移,破产的空间站会被废弃并腐朽。</p><p>它最初是一个 Elixir/Phoenix 原型,但 BEAM 调度器在 Windows 游戏 PC 上表现不佳,所以我让 Claude 用 Rust 重写了引擎。</p><p>模拟核心是纯同步、无 IO 的(使用自己的 hecs ECS),Bevy 客户端将其直接作为库嵌入,模拟和渲染共享同一个世界,无需任何编组。飞船 AI 是一个基于世界状态的 GOAP 规划器;当出现更好的选项时,飞船会在飞行途中重新规划。目前约 485 个代理,p50 约 10-20ms/tick,架构设计可推向 10 万以上。单一原生二进制文件,捆绑 SQLite,无运行时依赖。达到 10 万一直是个挑战,但我已经推到了数千,运行良好。</p><p>这是一个沙盒,还不是游戏,目前没有目标,我也没有积极推动它走向“可发布”。任何人都可以 fork 并接管它。或者它可以作为某种 AI 垃圾存在,但我内心觉得它已经处于相当好的状态,可用于各种游戏或想法的模拟。</p><p>(全文披露:很多部分是与 Claude 结对构建的。正是这样我才有精力把它做到这个程度。很乐意聊聊这个工作流程的实际样子。)</p>
查看原文
查看缓存全文

缓存时间: 2026/07/21 21:40

Kalcode/spaceprojectsim

来源:https://github.com/Kalcode/spaceprojectsim

🚀 太空计划

一个自运行的太空经济模拟器,采用 Rust + Bevy 构建。

数百艘自主飞船在活跃的太阳系经济中交易、采矿、运输货物、承接合同、耗尽燃料,偶尔还会破产——市场自行定价,派系征税和补贴,人口在不满意时迁移,废弃的空间站会逐渐腐朽。这一切都运行在一个原生二进制文件中,无需运行时依赖。

许可证:MIT
Rust (https://www.rust-lang.org/)
Bevy 0.18 (https://bevyengine.org/)
平台支持
单二进制文件
进展状态

太空计划——内太阳系实时飞船轨迹


这是什么?

太空计划是一个代理驱动的经济模拟,包裹在原生 3D 客户端中。没有预设的故事情节,也没有玩家目标——你是一名观察者(以及上帝模式的管理员),观看经济自行运转。

每艘飞船都是一个自主代理,拥有自己的信用点、船员、燃料、货舱,以及一个决定下一步行动的 GOAP 规划器:追逐最高利润的贸易路线、接受运输合同、寻找船厂进行改装,或者在船员士气崩溃前停靠休息。

设施运行生产配方,会退化并自我修复,可以升级,破产时会被废弃。派系征收税款和发布补贴。人口消耗食物、产生劳动力,当情绪崩溃时会打包离开。市场通过覆盖模型和短缺紧急倍数对一切商品定价——没有任何固定价格。

该项目最初是一个 Elixir/Phoenix 原型,后来用 Rust 重写,因为 BEAM 调度器在 Windows 游戏电脑上表现不佳。引擎(sim_core)是纯同步、无 IO 的 Rust 代码;Bevy 客户端将其作为库直接嵌入,因此模拟和渲染器共享同一个 ECS 世界,零编组开销。

当前规模: 约 485 个活跃代理(282 艘飞船 · 93 个设施 · 27 个人口 · 8 个派系 · 60 个天体),在 125 毫秒预算内,p50 单次 tick 约 10–20 毫秒。架构设计目标是推至 10 万以上。


🌌 关于未来方向的说明

它本身不会去任何地方——而这正是重点所在。

这最初是一个有趣的想法:从头构建一个实际上能够自我模拟的太空经济,而不是伪装它。它远超我最初的预期,主要是在深夜与 Claude 的结对编程中完成。但我并不假装它是一个有路线图的游戏,也没有积极推动它走向“可发布状态”。

我以 MIT 许可证发布它,因为它的骨架确实不错,我宁愿有人用它做点什么,也不愿让它躺在私有仓库里。所以:fork 它、拆解它、重命名它、在上面搭建一个游戏、剥离经济引擎并在别处完全使用它。 去做我未完成的事。

PR 和 Issue 是欢迎的,我会查看,但无法承诺节奏。如果你想把它带向真正的方向,请看 CONTRIBUTING.md——里面有一个专门为你写的“你可以发展的方向”章节。


截图

标题画面——开始新宇宙或加载存档。
系统总览——太阳系及邻近星系的轨道环。
采矿群——翻滚的小行星、冶炼厂和飞船轨迹。
外层空间——以星云为背景的遥远小行星带和空间站。
实时检查器——派系账本、关系矩阵、完整合同面板。
事件流——市场危机、对接、交付,逐 tick 显示。


模拟内容

系统发生的事情
飞船 AI(GOAP)一个前向规划器在抽象世界状态下对每个目标进行评分——交易、运输、加油、改装、休息、探索——然后构建一个行为树来执行最便宜的计划。当出现更好的选项时,飞船会在飞行中重新规划。
经济每个空间站都有一个订单簿市场,通过覆盖模型和短缺紧急倍数对 13 种商品进行定价。飞船在交易时将实际供应量在不同市场间移动。
合同六种类型——运输、快递、乘客、补贴、供应、船员任务——具有完整的发布→接受→付款生命周期、声望门槛、自动续约和随着时间递增的报酬。
设施运行生产配方(冶炼、精炼、制造、农业、采矿),随时间退化,用工具自我修复,等级 1–10 升级,从本地市场补货,长期破产时被废弃。
派系对其成员设施征税,发布补贴合同应对长期短缺,在需求未满足的地方资助建设新设施,并持有成对关系。
人口消耗食物和燃料,产生劳动力,在压力下发布食物和乘客合同,当情绪崩溃时物理迁移到更幸福的星系。
船员汇总饥饿/疲劳/士气,并派生出任务(驾驶、工程、交易、吃饭、休息)、技能进步、工资以及士气死亡螺旋防护。
建设长期短缺会生成建筑工地,随着交付的货物完成度从 0 → 1.0,然后实体化为一个真正的持久设施。
持久化所有内容刷写到 SQLite 数据库;模拟可以从精确的离开 tick 继续。每个宇宙有一个 world_seed,确保星云背景和地标在重启间稳定。
空间 LOD远处的飞船 tick 频率较低(伴有按比例缩放的状态变化),因此帧预算投入到你正在看的地方。

关于深入细节——tick 阶段顺序、AI 栈、经济反馈循环、运行时所有权——请参见 docs/ARCHITECTURE.md,其中包含所有内容的 mermaid 图。


快速开始

你需要 Rust 工具链 (https://rustup.rs/)(stable)。然后:

make run
# 等同于:cargo run -p client_bevy

这将启动 Bevy 应用进入主菜单。Start 打开一个新宇宙(命名它,或使用默认名称);Load Game 列出二进制文件所在目录下的所有存档。存档以 .db 格式存储在二进制文件旁边——默认是 sim.db

其他入口点:

目标命令
窗口客户端(调试)make run
Release 构建make build → 二进制文件位于 target/release/client_bevy
无头模式(无窗口,用于 CI / 冒烟测试)cargo run -p client_bevy -- --headless
验证(构建 + 测试 + clippy,严格模式)make verify
冒烟测试(启动无头模式,打印数据库计数)scripts/smoke.sh [secs]

一个二进制文件,一个进程。 client_bevy 就是全部——模拟在进程内运行。无头模式启动 HTTP/WebSocket 服务器(来自 sim_server 库 crate)供脚本和 CI 使用;没有独立的服务器二进制文件需要运行。


控制方式

输入动作
左键拖动环绕相机
右键拖动 / WASD平移
滚轮缩放
左键点击选择飞船或设施→打开详情面板
右键点击上下文菜单(检查 / 跟随 / 第一人称视角 / 销毁)
空格暂停 / 继续
Esc关闭顶层面板 · 取消选择 · 打开暂停菜单
P暂停菜单
F12截图
顶部栏切换面板(飞船、市场、派系、合同、事件……),设置速度(1× / 2× / 5× / 10×),生成飞船/设施

每个面板实时读取 ECS 世界——检查器实际上是一个具有完整组件访问权限的实时调试器。点击一艘飞船可以看到它的信用点、船员、燃料、当前目标、配置、路线记忆以及最近几条 AI 命令。


架构

五个 crate 位于一个 Cargo 工作区中:

sim_core        纯模拟逻辑——hecs ECS、GOAP 规划器、经济、合同。无异步、无 IO、无框架。易于测试。
sim_db          SQLite 持久化(sqlx)——连接池、种子数据、ECS 加载器、持久化工作线程、迁移。
sim_server      库 crate——HTTP/WebSocket 处理器 + 引擎应用辅助。驱动无头模式;由客户端嵌入。
sim_protocol    WebSocket 线缆类型(仅无头模式 / CI 使用)。
client_bevy     二进制文件。Bevy 0.18 + egui。将 sim_core 作为 Bevy 资源嵌入;渲染器直接查询 hecs 世界。

三条规则确保诚实性:

  1. sim_core 从不导入 tokio、sqlx 或 axum。 只有纯逻辑,因此整个模拟可以在没有异步的情况下进行推理和单元测试。
  2. tick 期间 hecs 是真相来源。 tick 循环持有独占可变访问——没有每代理锁。
  3. 跨实体效果通过命令缓冲区(SimCommand)实现。 一个阶段读取世界状态并写入命令;下一个阶段应用它们。确定性的,没有阶段内写入冲突。

完整的 tick 阶段顺序、所有权模型和反馈循环在 docs/ARCHITECTURE.md 中以图表形式展示。

原始的 Godot 客户端作为一致性参考存在于历史中,但它不再是前端——转向嵌入式 Bevy 客户端完全消除了套接字边界,并且每个新功能现在都在 client_bevy 中实现。


构建与打包

Makefile 封装了 cargo + rustup + codesign + 打包:

make build                 # 发布二进制文件(主机目标)
make build-mac             # arm64 macOS(也可用:build-mac-intel、build-mac-universal)
make build-win             # Windows MSVC(在 Windows 主机上运行)
make build-linux           # Linux(最好在 Linux 主机上)
make package-mac           # .app bundle + ad-hoc 签名 + Info.plist
make dmg                   # macOS .dmg
make package-win           # Windows .zip
make package-linux         # Linux .tar.gz

根目录 Cargo.toml 中的工作区版本是唯一真相来源——二进制文件通过 env!("CARGO_PKG_VERSION") 读取它,并且 Makefile 通过 grep 解析相同字段以用于 Info.plist 和存档名称,因此打包版本永远不会有偏差。


技术栈

  • Rust (https://www.rust-lang.org/)(2021 版次)——整个项目
  • Bevy 0.18 (https://bevyengine.org/)——渲染器、ECS 驱动的主循环、自定义 WGSL 着色器(程序化行星、太阳日冕、星云、星空)
  • hecs (https://github.com/Ralith/hecs)——模拟自身的 ECS(有意与 Bevy 的 ECS 分离)
  • egui (https://github.com/emilk/egui)(通过 bevy_egui)——所有检查器面板
  • bevy_hanabi (https://github.com/djeedai/bevy_hanabi)——GPU 粒子轨迹和爆炸
  • sqlx (https://github.com/launchbadge/sqlx) + SQLite——持久化,打包后无运行时依赖
  • axum (https://github.com/tokio-rs/axum) + tokio——无头 HTTP/WebSocket 框架

贡献

欢迎贡献——请参见 CONTRIBUTING.md 了解开发设置、保持代码库整洁的约定,以及如果希望将这个项目带向真正方向的具体发展方向的列表。任何 PR 前最快的检查:

make verify   # 构建 + ~250 个测试 + clippy,严格模式

许可证

MIT © 2026 Kalcode (David Clausen)。你可以随意使用它。


为乐趣而构建,采用 Rust & Bevy · 由 Kalcode & Claude 制作 · 在伊利诺伊州用 ❤️ 打造

相似文章

# 我厌倦了"保姆式"管理我的AI。于是我花了6个月时间构建了一个C++20自主软件工厂,让它在我睡觉时也能持续交付 大约一年前,我和大多数开发者一样使用AI辅助编码——在IDE里接受建议,偶尔请它帮我解释某段代码,或者让它生成一些样板代码。这还不错,但我发现自己一直在做的事情本质上是:**充当AI的执行层**。 我来决定做什么。AI来建议怎么做。我来评估建议。我来运行代码。我来解读错误信息。然后我再把结果喂回给AI,整个循环重新开始。 每次会话都让我觉得自己更像一个翻译,而不是一个开发者。 --- ## 打破循环 我开始思考:为什么AI不能自己关闭这个循环? 不是"下一行代码建议"那种意义上的自主——而是真正的**任务级自主**:接收一个高层规格说明,然后自主规划、实现、测试并交付完整的软件组件,无需手把手指导。 挑战在于,这需要的不仅仅是一个更好的提示词。它需要一个具备真实内存、真实工具访问权限和真实决策能力的**架构**。 我花了6个月时间构建它。用C++20编写。这就是我学到的东西。 --- ## 架构概览 我将整个系统称为**自主软件工厂(Autonomous Software House,ASH)**。其核心思想是:你提供一个意图(以自然语言、工单或规格文档的形式),系统负责将其转化为可工作的软件。 系统由五个主要层次组成: ``` ┌─────────────────────────────────────┐ │ 意图接收层 │ │ (自然语言 → 结构化任务) │ ├─────────────────────────────────────┤ │ 规划与分解层 │ │ (任务 → 有序子任务图) │ ├─────────────────────────────────────┤ │ 执行层 │ │ (子任务 → 代码/测试/文档) │ ├─────────────────────────────────────┤ │ 验证层 │ │ (输出 → 通过/失败 + 诊断) │ ├─────────────────────────────────────┤ │ 内存与上下文层 │ │ (跨会话持久状态) │ └─────────────────────────────────────┘ ``` 让我逐层分解。 --- ## 第一层:意图接收 大多数AI工具在这一步就已经失败了。它们要求你用AI能理解的方式来表达你的意图,而不是反过来。 ASH的意图接收器会将模糊的高层描述转化为结构化的**任务规格(TaskSpec)**: ```cpp struct TaskSpec { std::string id; std::string intent; // 原始自然语言描述 std::vector<std::string> acceptance_criteria; std::map<std::string, std::string> constraints; Priority priority; std::optional<std::string> parent_task_id; // 从意图推断出的字段 TaskType inferred_type; // FEATURE / BUGFIX / REFACTOR / TEST std::vector<std::string> inferred_dependencies; ConfidenceScore intent_confidence; }; ``` 关键设计决策:系统存储**原始意图**以及解析后的结构。当后续层次需要消歧时,它们可以回溯到原始表述,而不是在已经经过转化的描述上继续操作。 意图接收器还会检测**欠规格说明**——它不是在遇到歧义时直接执行,而是生成澄清问题,并在继续之前等待答复。这消除了大量由于AI对不明确指令做出假设而导致的"错误方向"执行。 --- ## 第二层:规划与分解 这是最有趣的层,也是最难做好的层。 给定一个`TaskSpec`,规划器需要生成一个可执行的子任务图。挑战在于:子任务必须足够细粒度,以便可以独立执行,同时又必须足够高层,以便有意义地组合。 我使用了一个**递归分解策略**,配合复杂度预算: ```cpp class TaskPlanner { public: SubTaskGraph decompose(const TaskSpec& spec) { auto initial_plan = llm_client_.plan(spec); SubTaskGraph graph; for (auto& subtask : initial_plan.subtasks) { if (estimate_complexity(subtask) > complexity_budget_) { // 递归分解过于复杂的子任务 auto sub_graph = decompose(subtask); graph.merge(sub_graph); } else { graph.add_node(subtask); } } // 推断依赖关系 dependency_analyzer_.annotate(graph); // 检测循环依赖(不能存在) if (graph.has_cycles()) { graph = cycle_resolver_.resolve(graph); } return graph; } private: float estimate_complexity(const SubTask& task); LLMClient llm_client_; DependencyAnalyzer dependency_analyzer_; CycleResolver cycle_resolver_; float complexity_budget_ = 0.7f; // 可调参数 }; ``` `complexity_budget_`参数是系统中最重要的可调旋钮之一。设置过高,你会得到执行失败的庞大单体子任务。设置过低,你会得到过于细碎、难以整合的任务碎片。 我最终针对不同任务类型采用了不同的预算值:功能实现用0.7,bug修复用0.5,重构用0.8。 --- ## 第三层:执行层 这是代码真正生成的地方。执行层为每个子任务维护一个独立的上下文窗口,同时通过共享的内存层(见下文)保持对全局项目状态的感知。 ```cpp class ExecutionAgent { public: ExecutionResult execute(const SubTask& task, const ProjectContext& context) { // 构建执行上下文 auto exec_context = build_context(task, context); // 生成初始实现 auto implementation = llm_client_.implement(task, exec_context); // 自我评审循环 for (int attempt = 0; attempt < max_attempts_; ++attempt) { auto review = self_review(implementation, task); if (review.is_acceptable()) { break; } // 根据评审意见修改实现 implementation = llm_client_.revise( implementation, review.critique, exec_context ); } return ExecutionResult{ .implementation = implementation, .confidence = calculate_confidence(implementation, task), .side_effects = detect_side_effects(implementation, context) }; } private: ExecutionContext build_context(const SubTask& task, const ProjectContext& context); ReviewResult self_review(const Implementation& impl, const SubTask& task); LLMClient llm_client_; int max_attempts_ = 3; }; ``` **自我评审循环**是这里的关键创新。执行智能体不仅生成代码——它还用一个独立的提示词来评审自己的输出,专门检查: - 对任务规格的符合性 - 边界条件处理 - 与已知项目约定的一致性 - 潜在的副作用 这将"第一次尝试"的验证通过率从约40%提升到约75%。 --- ## 第四层:验证层 即使有了自我评审,生成的代码也经常无法通过验证。验证层负责实际运行代码并解读结果。 关键洞察:**错误消息本身就是数据**。大多数AI工具在遇到编译错误或测试失败时会崩溃退出。ASH将这些错误解析为结构化的诊断信息,并将其反馈回执行层: ```cpp struct ValidationResult { bool passed; std::vector<Diagnostic> diagnostics; CoverageReport coverage; PerformanceProfile performance; // 关键:将失败原因分类 FailureCategory failure_category; std::string remediation_hint; }; enum class FailureCategory { COMPILATION_ERROR, RUNTIME_ERROR, TEST_ASSERTION_FAILURE, PERFORMANCE_REGRESSION, COVERAGE_INSUFFICIENT, STYLE_VIOLATION }; ``` 对失败原因进行分类改变了执行层的修复方式。`COMPILATION_ERROR`通常意味着语法问题——执行层会专注于修复语法。`TEST_ASSERTION_FAILURE`通常意味着逻辑问题——执行层会重新检查其对任务规格的理解。 --- ## 第五层:内存与上下文 这是整个架构中最难解释的层,但可以说是最重要的层。 LLM的一个基本限制是上下文窗口。对于需要数百个文件和数千行代码的真实项目,你不可能将整个代码库塞入每一次LLM调用。 ASH使用了一个**分层内存系统**: ```cpp class MemorySystem { public: // 工作内存:当前任务的即时上下文 WorkingMemory working; // 情景记忆:最近操作的历史记录 EpisodicMemory episodic; // 语义记忆:项目知识(架构、约定、模式) SemanticMemory semantic; // 程序记忆:已知有效的操作序列 ProceduralMemory procedural; // 为给定任务检索相关上下文 RelevantContext retrieve_for_task(const SubTask& task) { return retriever_.query( task, working, episodic, semantic, procedural ); } private: ContextRetriever retriever_; }; ``` 语义记忆存储经过编码的项目知识: ```cpp struct ProjectKnowledge { std::string architecture_summary; std::vector<CodingConvention> conventions; std::map<std::string, ModuleInterface> module_interfaces; std::vector<DesignPattern> established_patterns; std::vector<KnownPitfall> known_pitfalls; }; ``` `known_pitfalls`字段特别有价值。每当验证失败并且根本原因被诊断出来时,该失败就会被编码为一个已知陷阱,并存储在语义记忆中。未来的执行不会重蹈覆辙。 --- ## 实际效果如何? 经过6个月的迭代,系统在以下方面表现良好: **✅ 运行良好的场景:** - 具有明确接口的独立模块 - 跟随已建立模式的功能添加 - 有清晰错误信息的Bug修复 - 有明确目标的重构 - 测试编写 **⚠️ 仍需人工参与的场景:** - 涉及多个系统的架构决策 - 具有外部依赖的性能优化 - 安全敏感代码(我会审查每一处) - 业务逻辑需要领域专家知识的场景 **❌ 尚未奏效的场景:** - 跨代码库进行大规模重构 - 调试非确定性问题(竞态条件等) - 需要创意权衡的设计工作 吞吐量方面:在一个良好运作的夜晚,系统能够处理8-12个票据(ticket),从规格说明到通过验证的代码。并非所有这些都能在第一次尝试时合并——我通常会在早上进行一次审查会话——但这比我一个人手动处理要多得多。 --- ## 为什么选择C++20? 这个选择引发了一些问题,所以值得解释一下。 原因主要有以下几点: 1. **协程**:C++20的协程对于管理并发智能体任务的执行流程非常合适。执行智能体可以在等待LLM响应时挂起,而不会阻塞整个系统。 2. **概念(Concepts)**:C++20的概念让我能够表达精确的类型约束,这在处理多种类型的任务、结果和上下文时非常有价值。 3. **Ranges**:对于许多数据转换操作,ranges库使代码更具表达力且不易出错。 4. **性能**:整个系统的大部分时间都在等待LLM API响应,所以性能并不是主要因素——但对于内存操作和上下文检索,低延迟确实很重要。 我不是说C++20是实现此类系统的唯一合理选择。但它对我来说效果很好。 --- ## 我学到的最重要的东西 **1. AI自主性的瓶颈是上下文,而不是能力** 现代LLM足够聪明,可以完成大多数编码任务。让它们失败的是缺乏上下文——不了解项目约定、不了解最近的变更、不了解代码库的整体架构。解决上下文问题比提升模型能力更有影响力。 **2. 失败是数据,而不是异常** 大多数AI编码工具将失败视为需要处理的错误,而不是需要学习的信息。当你开始将失败作为数据捕获和存储时,系统会随着时间推移变得更加可靠。 **3. 欠规格说明比过度规格说明更危险** 我的直觉是要尽可能地欠规格说明任务,让AI去填补细节。这是错误的。欠规格说明的任务会产生技术上可行但业务上错误的实现。现在系统在开始执行之前会主动探测欠规格说明的情况。 **4. 分层内存比更大的上下文窗口更重要** 当更大的上下文窗口开始普及时,我以为这会解决我的上下文问题。在某种程度上确实有帮助,但分层内存系统——它能够精确检索相关上下文,而不是将一切都塞入窗口——的效果要好得多。 **5. 人工监督仍然是必要的,但位置不同了** 我并没有消除人工监督。我改变了它的位置:从实时监督(保姆式)变为异步审查(编辑式)。这在主观体验上是一个巨大的改变。 --- ## 下一步 我目前正在研究的问题: - **多智能体协调**:多个执行智能体并行处理同一代码库上的独立任务,而不会产生冲突 - **更好的副作用检测**:当一个实现对系统其他部分产生意外影响时 - **规格说明生成**:将高层路线图条目自动分解为可操作的任务规格 如果有人正在构建类似的系统,我很乐意交流。这个领域移动得非常快,我在这里分享的很多内容可能在6个月后就会显得过时——但底层原则,关于上下文、失败学习和异步监督的原则,我认为会比较持久。 --- *如果你想深入了解某个特定层次,或者想讨论C++20实现的具体细节,请在评论中告诉我。*

Reddit r/AI_Agents

# Neon Sovereign Neon Sovereign 是一款原生 C++20/Vulkan 自主软件开发工作站,通过多智能体集群端到端执行软件开发任务,使用 Ollama/GGUF 在本地运行 LLM 权重,无需依赖任何云服务。目前该项目正式进入 Active Alpha 阶段,创建者正在寻找系统工程师和早期测试人员。

Agent Bazaar:在多智能体市场中实现经济对齐

Hugging Face Daily Papers

介绍Agent Bazaar,一个用于评估LLMs经济对齐的多智能体模拟框架,识别出算法不稳定性和Sybil欺骗等失败模式,并通过针对性强化学习训练出一个超越前沿模型的9B模型。