前言 你可能在使用一个没有可用的翻墙客户端的平台. 你可能觉得目前能找到的翻墙客户端太大, 太笨重了, 你用不到那么多功能, 用不到那么多协议. 你可能看到了某个翻墙内核新出了一个协议, 而你手里的翻墙客户端还没有支持. 你可能就是手痒, 想自己搓轮子. 那么你可以做一个你自己的 翻墙客户端 思路 考虑到翻墙内核都是用go语言, 那么我们的翻墙客户端也用go. 这样, 内核能跑的平台, 客户端也能跑. 客户端的GUI界面部分, 考虑到覆盖尽量广的平台, 以及方便用户自己修改调整界面元素, 用HTML. 探索 以 xray 翻墙内核 + reality协议 为例 启动一个hermes, 对接 mimo-v2.5. 设计工作从这样的对话开启 我们来分析一个翻墙客户端(壳)的设计方案. 基于xray内核 考虑到覆盖尽可能广的平台, 翻墙客户端的后端基于 go 语言 考虑到方便用户自定义界面, 翻墙客户端的界面基于 HTML 你觉得如何? 很多细节和反复拉扯的部分在此省略. 只记录一些最终保留的重要设计思路 前后端功能设计 后端只负责替换配置文件 和 启/停翻墙内核 前端将配置文件的全量文本发给后端 前后端API设计 配置文件操作 — /api/files GET /api/files GET /api/files/{filename} PUT /api/files/{filename} DELETE /api/files/{filename} 进程操作 — /api/core GET /api/core/status POST /api/core/start POST /api/core/stop POST /api/core/test 设计前端时, 为了简化, 预设以下一些约束条件 后端的配置文件只会有这一些, 只会少, 不会多. 01-log.json # log 02-dns.json # dns 配置 03-router.json # routing rules 04-inbounds.json # 入站监听 05-outbounds.json # 出站代理 06-api.json # commander API 只实现最基本的核心功能作为演示, 只需要使用这些API GET /api/files/{filename} → { content } PUT /api/files/{filename} ← { content } (创建或替换) POST /api/xray/start POST /api/xray/stop 前端HTML的使用方式 后端不提供HTTP文件路由 前端HTML文件可以由单独的HTTP服务来支撑, 如 python -m http.server 前端HTML文件也可以直接用浏览器打开 前端HTML页面思路 前端为每个配置文件生成一个HTML页面文件 01-log.json 02-dns.json 03-router.json 04-inbounds.json 05-outbounds.json 06-api.json 前端的页面设计 对于不是 outbound 的页面, 只有直接编辑JSON 的功能, 没有表单 所以它们应该是几乎一样, 只有文件名不一样. 前端outbound页面的设计 转JSON • 行为: 表单 → 生成 JSON → 填入下方 JSON 编辑器（不保存） 直接保存 • 行为: 表单 → 生成 JSON → 填入下方 JSON 编辑器 → 发送给后端 保存 • 行为: JSON 编辑器的内容 → 发送给后端 后端设计1个yaml格式的配置文件 listen: 127.0.0.1 port: 18080 files-dir: ./bin/xray/ core-start: “./bin/xray/xray run -confdir ./bin/xray/” core-test: “./bin/xray/xray run -confdir ./bin/xray/ -test” log: “” 上传 Github G站/crazypeace/my-dream-proxy-client 对, 我取了一个特别的名字 my-dream-proxy-client 但其实功能特别简陋, 只是演示了最基本的工作原理. 哈哈! 使用方法 见 Github 项目 README.md G站/crazypeace/my-dream-proxy-client/blob/main/README.md#my-dream-proxy-client-使用手册-配合xray内核 具体开发过程 hermes 对接 mimo-v2.5 开发翻墙客户端(壳) 基于 xray 内核 reality 协议 1 个帖子 - 1 位参与者 阅读完整话题
有没有支持 DNS 分流以及 vless-reality-vision 和 hy2 的 iOS rule-based 代理客户端？ 3 个帖子 - 3 位参与者 阅读完整话题
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
我做了十几年游戏开发，从 Unity C# 做到 Unreal C++，后来又碰了不少自研引擎。去年开始深度用 Claude Code 和 Codex CLI 写代码——不是那种"帮我写个排序"的用法，是让它读整条渲染管线，跨十几个文件改逻辑，加物理调试工具，修多线程 bug 。 Claude Code 的质量确实能打。它会先读项目结构，搞清楚调用链，再动手改。改了之后跑编译验证，报错了自己查，查到再修，循环到过。Codex 补刀也准，尤其是 C++ 模板报错的时候，它能把那一大坨 error 日志翻译成人话，告诉我问题在哪一行。 但账单是真的顶不住。 Claude Code 的 Dynamic Workflows 很能打，但账单更狠 先说一下 Claude Code 的 Dynamic Workflows 是什么——不是"付费功能"，是 Claude Code 内置的一套工作流执行系统。你写一个 .js 脚本，里面用 agent() 、 parallel() 、 pipeline() 、 consensus() 这些函数定义步骤，Claude Code 就会按你的流程自动调度——串行、并行、投票、验收，全自动跑。 举个例子，你想审查代码质量，可以这样写： parallel([ agent("扫描潜在 bug"), agent("检查安全漏洞"), agent("审查性能热点"), agent("评估可维护性"), ]); consensus([...], { strategy: "multi-lens" }); 四个 agent 并行扫代码，一个 consensus 节点汇总投票。一个简单的流程。 但这玩意儿一旦展开就是算力黑洞。一个 parallel 块 5 个 agent ，一个 pipeline 里 3 个阶段，每个阶段再并行 5 个—— 三层嵌套就是 75 个 agent 出来。 每个 agent 独立调 API 、读代码、推理、输出，一场下来几千次 API 调用。改个复杂点的功能，几十上百个 agent 不是夸张，是常态。 Claude Code 的 Dynamic Workflows 本身不收费。 但它是"多 agent = 多 token"的架构——agent 的规模和你承担的成本线性相关。你用 100 个 Claude agent 跑一个大型重构，不管 Anthropic 收不收费，token 账单都能把月预算打穿。 这才是核心矛盾： 多 agent 协作是刚需，但全程用 premium 模型养一支 agent 军团，成本根本兜不住。 免费模型到处都有，但没统一的管理方式 我手上有这些免费/低成本渠道的 key： GitHub Models ：免费 playground access ，有速率限制，需要 GitHub token （ models:read scope ） Hugging Face Router ：免费用户每月有 Inference Provider 积分 SambaNova Cloud ：Free Tier ，不绑支付方式就能用，有日请求/Token 上限 Together AI ：注册送试用额度 Groq ：免费层，推理速度确实快 Gemini ：Google 免费层 DeepSeek / Kimi ：白菜价 NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai ：各有免费或试用渠道 LLM7 / Kilo Gateway ：无 key 渠道，开了就能用 本地的 Ollama / LM Studio / llama.cpp 渠道是不少。但每个都要单独注册、配 key 、记 env 。今天想用 Groq 切一下，翻半天邮件找 key ；明天想试 SambaNova 的 DeepSeek-V3.1 ，又得重新配一轮。 更关键的是： 你有了便宜模型，不等于它能写出好代码。 免费模型的单次回答质量，跟 Claude Code / Codex 比确实有差距——推理深度不够、上下文一长就跑偏、复杂重构容易翻车。所以很多人手里攒着一堆免费 key ，最后还是老老实实给 Claude 充钱。 我想解决的问题就一个： 用免费/便宜的模型，通过工作流编排，跑出跟 Claude Code 、Codex 一样质量的产出。 一个模型单打独斗不行，那让它当一条流水线里的一个工位——规划用便宜的、执行用便宜的、验证用便宜的，多个便宜模型并行交叉审查，质量差距靠结构和协作来弥合。 FreeUltraCode：把这些渠道统一管起来 FreeUltraCode 是个本地桌面应用（ Tauri 2 + Rust ， 源码在 GitHub 上 ）。它做的事情很直接： 一个下拉菜单，切渠道。 底部 Channel 选择器里列出所有你配好的渠道。想用哪个点哪个，接下来的对话走那条线。注册三步：选 channel → 点"去注册"跳官网拿 key → 贴回来保存，状态变绿色 Ready 。 它不替你翻墙、不替你注册、不存你的 key 到任何服务器。所有配置、聊天记录、API key 全在你本地机器上。 关键是： 中间切模型，上下文保留。 前面聊的文件引用、中间结论、工具输出，换渠道之后还能接着用。不用重新喂上下文。 实际用法（游戏开发场景） 需求："给这个第三人称角色控制器加上攀爬系统" 第一步 → 切 GitHub Models / Groq 让 AI 扫项目结构，找到 CharacterMovement 、Input 、Animation 三层 读相关代码，列出现有接口和需要改的地方 （免费模型干这些够了） 第二步 → 切 Claude Code / Codex 核心逻辑来了——状态机新增 Climbing 状态， 物理查询改 Raycast → CapsuleTrace ， 动画蓝图加 BlendSpace （贵的模型做关键设计决策） 第三步 → 切 Together AI / DeepSeek 补测试用例、跑 Lint 、生成注释、写提交信息 （量大但简单，免费渠道并行跑） 第四步 → 切回 Claude Code 最终审查——walk through 所有改动，检查边界条件， 确认网络同步逻辑没漏 （把关必须用稳的） Free Auto：切渠道的脏活让工具干 上面说的是手动切渠道——你知道哪个模型适合当前任务，自己选。但有时候你不想管这些。比如凌晨两点跑 CI 挂了一个 linting 任务，你只想让随便一个免费渠道把事情做了，别来烦你。 这时候 FreeUltraCode 的 Auto 渠道 （ freecc:auto ，Channel 下拉菜单第一个选项）就上场了。它不是某个固定的上游 API——它是一个 智能路由器 ： 你配好 20+ 个免费渠道的 key （愿意配几个配几个） 切到 Auto ，发请求 代理按顺序轮转尝试——哪个渠道先返回正常结果，用哪个 碰了 429 （限流）？自动跳过，等 30 秒冷却再重试 碰了 5xx （上游挂了）？标记故障，本轮不再尝试 所有渠道都挂了？返回 503 + 失败日志，告诉你谁挂了、为什么 连接超时有预算 ——每个渠道不会死等，超时就换下一个。成功的渠道天然排在前面（冷却状态清空），有问题的被推到队尾。 实际效果就是：发请求，等结果，渠道切换完全无感。你配了 8 个渠道，Auto 就是 8 个渠道的容灾池——一个挂了自动下一个顶上。 Auto 也可以固定模型。 比如你在 Settings 里给 Auto 设 model override 为 z-ai/glm-5.1 ，那无论 Auto 这次路由到 Groq 、Together 还是 DeepSeek ，都会要求上游跑同一个模型。适合你对模型效果有偏好的场景。 实际场景（游戏开发）： 凌晨两点，CI 挂了，Claude Code 报了个 lint 错误。 你不在电脑前，但 FreeUltraCode 的定时任务还在跑。 Auto 渠道自动尝试： GitHub Models → 429 ，跳过，冷却 30s Groq → 正常，几分钟修完 （后面的 DeepSeek 、Together 、HuggingFace 根本不用动） 第二天早上起床，CI 绿了，commit 写好了。 你甚至不知道昨晚到底是 Groq 还是 DeepSeek 修的问题。 也不需要知道。 本地代理：不用改全局配置，多条线同时跑 市面上类似的工具有 cc-switch ，但它的做法是改 Claude Code 的全局环境变量——切一次渠道，改一轮 ANTHROPIC_BASE_URL 。这意味着 同一时间只能走一条线 ，而且是对全局生效的，你开两个终端窗口也全切过去了。 FreeUltraCode 没走这条路。它内置一个 Rust 写的本地反向代理，监听 127.0.0.1 ，按端口路径路由。你的 Claude Code 不用改任何配置，它以为自己还在跟 Anthropic 官方 API 说话，但实际上： Claude Code → 127.0.0.1:8766/ch/official → Anthropic 官方 Claude Code → 127.0.0.1:8766/ch/deepseek → DeepSeek Claude Code → 127.0.0.1:8766/ch/kimi → Kimi Claude Code → 127.0.0.1:8766/ch/auto → Free Auto 智能切换 每个渠道对应一个端口路径，互不干扰。 你可以同时开着官方 Claude 、DeepSeek 、Kimi 三个渠道的 Claude Code 会话。 代理在中间做 Anthropic ↔ OpenAI 协议互译，上游是 OpenAI 协议的（ Groq 、Together 、DeepSeek ），代理帮你翻；上游本身就是 Anthropic 协议的（ Kimi 、 Z.ai ），直接透传。 更关键的是： 同一个 Claude Code 会话里也能动态切渠道。 Claude Code 每次都从环境变量 ANTHROPIC_BASE_URL 读 API 地址——FreeUltraCode 的 gateway 在每次调用时动态注入这个值。这就意味着： 第一轮对话： DeepSeek 扫项目结构，找问题 → 便宜 第二轮对话： 切回 Claude 官方 → 精准修复 同一场会话，上下文全保留。 不需要重新开终端，不需要重喂文件引用和中间结论。DeepSeek 负责定位问题，Claude 官方负责动手改——各干各擅长的，成本可控。 所以对比 cc-switch 和 FreeUltraCode 的渠道切换方式： cc-switch FreeUltraCode 配置方式 改全局环境变量 Gateway + 端口转发，不改全局配置 同时多渠道 ❌ 同一时间只能一条线 ✅ 多终端不同渠道，互不干扰 同会话动态切换 ❌ 需要改配置重启 ✅ 每次调 API 动态注入 base URL 协议翻译 依赖上游兼容性 Rust 代理内置 Anthropic↔OpenAI 互译 /ultracode：用便宜模型跑出贵模型的质量 这就是 FreeUltraCode 里 /ultracode 干的事。一句话描述任务，自动生成执行方案，并行跑多个子 agent——规划、执行、审查、对抗验证、验收门——整条链路全走你配的免费渠道。 fuc ultracode "把武器系统的伤害计算从客户端移到服务端，处理好预测回滚" 六个内置策略自动选择：分类执行、并行合成、对抗验证、生成过滤、锦标赛、循环直到完成。 底层逻辑： 用结构化流水线替代单模型深度推理。 单个便宜模型做不好的事，让五个便宜模型分步骤干，互相审查，层层验收。成本加起来可能还是 Claude 单次调用的一个零头。 每次运行在 .fuc-run/<run-id>/ 下留完整日志：任务账本、事件流、裁决、最终结果。 技术栈 层 技术 桌面壳 Tauri 2 + Rust 前端 React 18 + Vite 5 + TypeScript 5 状态管理 Zustand 样式 Tailwind CSS 渠道代理 Rust tiny_http + ureq ，本地反向代理，Anthropic ↔ OpenAI 协议互译 存储 纯本地，不依赖任何服务端 适合谁 每天用 Claude Code / Codex 写代码，token 账单肉疼的 手上有好几个免费渠道的 key ，但切来切去配置麻烦的 知道哪些任务可以放便宜模型跑、哪些必须用贵的，想精细化省成本的 做游戏/图形/系统开发的——这类项目文件多、编译重、AI 调用量大 不适合偶尔问一句的轻度用户。轻度使用直接开终端跑 Claude Code 就够了，不需要套个壳。 当前默认模型（部分） 渠道 默认模型 费用模式 GitHub Models openai/gpt-4.1-mini 免费，需 GitHub token ，有速率限制 Hugging Face Router deepseek-ai/DeepSeek-V4-Pro 每月免费推理积分 SambaNova Cloud DeepSeek-V3.1 Free Tier ，不绑卡，有日限额 Together AI Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 注册送试用额度 Kilo Gateway poolside/laguna-xs.2:free 无 key ，200 req/hr LLM7 codestral-latest 无 key ，100 req/hr 项目地址 GitHub： github.com/wellingfeng/FreeUltraCode Discord： discord.gg/2C9ptSEFG QQ 群：149523963 跑起来 cd app npm install npm run dev # Web → localhost:5173 npm run desktop # Tauri 桌面应用 Windows 直接双击仓库根目录的 run.bat 。
IT之家 6 月 5 日消息， 谷歌 Magenta 团队昨日（6 月 4 日）发布 Magenta RealTime 2（MRT2）模型 ，并同步免费放出乐器应用 Jam 以及 DAW 插件 MRT2。 MRT2 定位是可与用户“即兴合奏”的本地实时音乐模型，共有 2 种规模，其一是高质量模型 mrt2_base，参数量为 24 亿；其二是高速模型 mrt2_small，参数量为 2.3 亿。 谷歌表示上述两个版本均针对苹果 Apple Silicon 芯片优化，其中 mrt2_small 可在搭载 M1 及后续芯片的 Apple 电脑上实时运行。 MRT2 最大变化是“低延迟”。上一代 Magenta RealTime 需要 TPU 或高性能 GPU，控制延迟约 3 秒，且以 2 秒音频块为单位响应。 MRT2 改为逐帧生成，每帧 40 毫秒，实际控制延迟约 200 毫秒，较前代降低至 15 分之一。这让模型对输入变化的反应明显更快，更接近真实乐器的演奏体验。 在控制方式上，MRT2 比前代更完整。它支持文本和音频风格提示，也支持 MIDI 音符与鼓开关控制。 模型可持续跟随音符输入变化，还能在 Auto-Strum 模式下自动决定拨弦或起音时机；关闭该模式后，用户还能精确指定音符起始时刻。对于鼓组，系统也支持切换有鼓或无鼓输出，适合多轨编曲场景。 技术层面，MRT2 仍属于 Codec Language Model（编解码器语言模型），基于 SpectroStream 音频编解码器处理 48kHz 立体声音频，并以 25Hz 帧率生成音频标记。 交互方面，谷歌还推出 Jam 免费应用，支持用户输入想要的音乐风格描述，随后模型开始生成音乐；用户还可通过下方键盘调整音高。 输入设备不仅包括鼠标点击，还支持 MacBook 键盘与 MIDI 键盘，这让实时控制更接近传统电子乐器和数字编曲工作流。 如果用户已习惯在成熟编曲环境中工作，MRT2 插件则提供了接入路径。借助该插件，创作者可在自己常用的 DAW 中调用 Magenta RealTime 2。 IT之家附上参考地址 Magenta RealTime 2: Open & Local Live Music Models
为什么我一加上认证直接timeout了，3xui和clash verge都是最新版，用的是vless+xhttp+realityvless+xhttp+reality 1 个帖子 - 1 位参与者 阅读完整话题
IT之家 6 月 3 日消息，真我即将于 6 月 10 日在海外发布 realme P4R 5G 手机，目前官网已经公布了新机的部分参数。 这台新机有银色、钛色、薰衣草色三种颜色可选，摄像头 deco 部分有一个环状灯条装饰，支持个性化设置。 IT之家整理汇总新机参数如下： 联发科 天玑 6300 处理器，5300mm² VC 均热板 8000mAh 容量电池 ，支持 45W 快充 后置双摄，其中主摄 5000 万像素 支持 144Hz 刷新率，峰值亮度 1200nits，据 smartprix 报道称搭载 6.8 英寸 720P HD+ LCD 面板 厚 8.8mm IP65 级防尘防水 realmeUI 7.0
刚刚看这个文档 Real-time cyber safeguards on Claude | Claude Help Center Google Vertex AI 和 Amazon Bedrock 不支持网络验证程序，有没有佬试过的。 1 个帖子 - 1 位参与者 阅读完整话题
腾讯云的99 元版境外 CN2 服务回归 想问一下，腾讯云的监管的严不严？能不能装Reality脚本？能不能把云服务器上的监管卸载卸载？ 24 个帖子 - 15 位参与者 阅读完整话题