标签：#ai

Fable is back. The Commerce Department announced yesterday it has lifted the export controls it...

Look at tomorrow's track list and count the rooms that have absolutely nothing to do with...

I’m at the AI Engineer conference in San Francisco this week. The event has every major brand-name...

I’ve been covering Warp for a couple of years now, and its rapid evolution from a command-line...

The Problem LLM evaluation tools like Patronus AI excel at hallucination detection, toxicity checks, and semantic relevance. But they don't catch the structural failures: A JSON response missing required fields A function call with malformed parameters Output that violates schema constraints Latency budget overruns silently degrading UX Cost explosions from runaway token usage These aren't hallucinations. They're verification failures. The Solution correctover-patronus is an adapter that runs Correctover's 87 deterministic verification rules as native Patronus evaluators. Every verdict comes with a recomputable proof hash — meaning you can verify the verifier. pip install correctover-patronus The 6 Dimensions Dimension What It Checks Example Structure Output format validity JSON parses correctly Schema Field presence & types Required fields exist Identity Semantic relevance to input Response addresses the question Integrity Forbidden pattern absence No Tracebacks or error messages Latency Response time budget Under 30s threshold Cost Token usage budget Under 10k token limit Usage Full 6-Dimension Verification from correctover_patronus import CorrectoverEvaluator , CorrectoverConfig config = CorrectoverConfig ( min_confidence = 0.7 , latency_rules = { " max_ms " : 5000 }, cost_rules = { " max_tokens " : 4000 } ) evaluator = CorrectoverEvaluator ( config = config ) result = evaluator . evaluate ( task_input = " Summarize this article... " , task_output = " The article discusses... " , task_context = { " source " : " article " , " word_count " : 1500 } ) print ( f " Overall: { result . score : . 2 f } ( { ' PASS ' if result . pass_ else ' FAIL ' } ) " ) print ( f " Proof hash: { result . metadata [ ' proof_hash ' ] } " ) for dim , info in result . metadata [ ' dimensions ' ]. items (): print ( f " { dim } : { info [ ' status ' ] } (score= { info [ ' score ' ] : . 2 f } ) " ) Individual Dimensions from correctover_patronus import correctover_structure , correctover_inte

How We Process 7,500 Product Images Daily Without Breaking the Pipeline A behind-the-scenes look at the technical workflow that keeps eCommerce image editing consistent at scale — and what breaks when you try to fully automate it. We process over 7,500 product images every single day. When you're running at that volume, even a 2% error rate means 150 broken images going out to clients' Amazon listings, Shopify stores, and product catalogs. A 2% error rate at that volume is a business problem, not a rounding error. This post is about what we learned building a pipeline that handles that volume reliably — the parts that automated well, the parts that didn't, and the specific technical decisions that made the difference. If you're a developer building an eCommerce image processing workflow, or a technical founder trying to figure out how to scale product photo operations, this is the breakdown I wish I'd had earlier. The Core Problem With Fully Automated Image Processing Every developer who builds an image processing pipeline goes through the same arc. Phase 1: "AI background removal is incredible. I'll automate everything." Phase 2: "Why are 30% of these outputs rejected by Amazon?" Phase 3: "Why is my client's return rate going up?" Phase 4: "I need to add human review back in. But where?" The issue isn't that AI image processing is bad. It's that it's inconsistent in ways that are difficult to detect automatically — and the failures that matter most are the ones that look fine at thumbnail resolution but fail at 1:1 zoom or fail RGB verification. Here's what a naive automated pipeline misses: # What developers think background removal does: result = ai_remove_background ( image ) # Returns: clean product on transparent background # What actually happens on complex products: # - Jewelry chains: partial removal, missing links # - Fabric with lace: holes in the garment, not the background # - Transparent products: product partially removed # - Products matching backgro

An agent opened a pull request on our service last week. Six hundred lines. It rewrote how we handle webhook retries and deduplication, an area that is fiddly and easy to get subtly wrong. The diff was clean. The tests were green. The commit messages were better than mine usually are. And I felt the specific dread that I think a lot of engineers are starting to feel in 2026. I was the reviewer. I had not written any of this. I had no idea why it was shaped the way it was. To review it properly, the way I would want my own code reviewed, I was looking at the better part of an hour of carefully reconstructing intent from the code itself. I did not have that hour. So I did what almost everyone does in that situation, which is skim it, decide it looked reasonable, and approve. That moment is the actual problem with AI-written code, and it is not the one people argue about. The bottleneck moved, and most teams have not adjusted The tired debate is whether agents write good code. In 2026 that argument is mostly over. They do. They plan, they read the codebase, they run the tests, they back out of dead ends, they open pull requests that clear most review bars. If you are still litigating whether the code is any good, you have not used a current agent in a while. But here is what follows from that, and it is the part teams have not absorbed: if writing the code is no longer the slow step, then reviewing it is. And review does not scale the way generation does. An agent can produce five well-tested pull requests before lunch. Your senior engineers cannot deeply review five pull requests before lunch, not on top of their own work. The volume went up and the review capacity did not, and something has to give. What gives is the depth of review. It degrades, quietly, into a skim. People approve fluent diffs they have not truly read, because reading them properly costs more time than anyone has. The green check still appears. It just means less than it used to. That is a governan

我讓三個 AI 各司其職寫程式：Codex 出測試、Grok 寫實作、Claude 驗收 這週我沒有讓單一 coding agent 從頭包到尾。我把流程拆成一條固定的契約： Codex 先寫測試，Grok 再寫實作去讓那些測試通過（只能改實作、不准動測試），Claude 獨立驗收才提交。 測試在實作之前就寫死，成為 Grok 必須滿足、且不能修改的規格。我先在一個 Zig 專案跑了兩個功能，後來又在一個 Rust + Turso 專案獨立重跑三個功能（見文末）——判斷一致：這條 pipeline 在 有嚴格測試當契約 的前提下可用；它省下的不是人力，而是把「錯誤發現點」往前、往獨立處移。這只是 workflow 可用性判定，不含可商用判定——後者要另算 token/seat 成本、隱私、rate limit 與審計，本文不碰。 實驗條件（可自行驗證） 工具： codex-cli 0.142.4 、 grok 0.2.77 (44e77bec3a) 、Claude Code（CLI，版本未記錄，屬已知量測缺口）。 專案：一個 Zig 0.16.0 codebase（私有 repo，commit hash 僅供我本地對照），加一個「回合後反思」功能。另在一個 Rust + Turso 專案上以同一條 pipeline 再跑一輪，見文末「換一個 stack 再驗一次」。 樣本：Zig n=2 個功能 （config surface、reflection module），共 15 個測試（4 + 11）；Rust + Turso n=3 個功能 （見文末）。兩者各自樣本都小。 出題命令： codex exec --sandbox read-only （單次、不寫檔）。 施工命令：Grok headless、可寫檔模式（write→test→fix）。 觸發 400 的命令：對 grok-composer-2.5-fast 傳 --effort （等同 reasoningEffort 參數）。 驗收命令： zig test <libs> --dep build_options --dep compat -Mroot=src/root.zig --test-filter "<功能前綴>" ；leak-detecting allocator 回報 0 leak。 樣本小，數字不外推；以下每個論斷都設計成能被另一個工程師在幾分鐘內驗證或反駁。 核心迴圈：測試先寫死，實作去追它 每個功能走五步，順序不可換： Codex 出測試 + 最小 stub 。stub 讓測試「能編譯、但在斷言上失敗」——這是真正的 RED，不是因為符號缺失而編不過。測試此刻就固定下來，之後不再改。 Claude 對照原始碼核對 測試。Codex 會猜 API（vtable 欄位、函式簽章、建構模式），必須逐一驗證符號存在才落地。 Claude 放進隔離的 git worktree ，跑到確定 RED：pass/fail 混合，每個失敗各有其原因。 Grok 寫實作 到 GREEN。任務只有一句： 讓這些已寫死的測試通過，只改實作、不准動測試。 測試是 Grok 不能碰的契約，不是它可以順手改綠的東西。 Claude 獨立驗收 （不採信 Grok 的自述）：跑測試、確認 0 leak、核對 diff 的正確性與改動範圍，才提交。 重點不是「三個比一個強」，而是 出測試的人跟寫實作的人不是同一個 agent ——測試因此成為獨立的規格，實作成為獨立的檢查。一個模型不能同時定義正確、又判定自己是否正確。 對照三個真實替代方案 單 agent 跑 TDD（自己出測試、自己實作） ：最快，但自我驗證風險最高。 人寫測試 + agent 實作 ：最可靠，測試由人把關；代價是人工成本最高。 本文的三 agent 分工 ：增加 orchestration 來回（見下），換到的是「假綠」風險下降——任何一環的自欺會在下一環被抓到。 選哪個，取決於你的錯誤成本 vs. 來回成本。 每家 CLI 的落地差異（用法決定，不是廠商能力差異） 三家我都只用了各自的一種模式，差異來自我怎麼接，不是模型智力： Codex ：我用 codex exec --sandbox read-only 的 單次 模式，讓它只「輸出」測試碼、不改檔。它其實支援 --sandbox workspace-write 與 exec resume （可多輪、可寫檔），但我刻意把它限縮成「出題者」，讓出題與施工不同源。誤把單次 read-only 模式當施工者用，會得到看似對、實際編不過的檔案。 Grok ：我用 headless、可寫檔模式跑 write→test→fix。踩到一個 參數相容性 的坑：在 grok 0.2

Here's an uncomfortable truth nobody wants to admit out loud: most teams can generate a working app in minutes now, but almost none of them can ship it to production without breaking something important. Only a small fraction of organizations have actually moved their AI-built systems past the pilot stage. The gap between "it works on my machine" and "it works for real users" has never been wider, and closing that gap is quickly becoming the single most valuable skill a developer can have this year. If you have been prompting your way to a working prototype and then hitting a wall when it's time to actually deploy, this guide walks through exactly how to close that gap, with working examples at every step. Why This Matters Right Now Vibe coding, meaning describing what you want in plain language and letting an AI model scaffold the implementation, has gone from a novelty to a default workflow. Developers are shipping REST APIs , auth flows, and full CRUD apps with a single well-written prompt. But speed of generation is not the same as readiness for production. Untested edge cases, missing validation, weak error handling, and security gaps show up constantly in AI-generated code because the model optimized for "looks correct" rather than "survives real traffic." The developers who stand out this year are not the ones who can generate code fastest. They are the ones who know how to validate it, harden it, and integrate it responsibly. Below is a practical checklist you can apply to any AI-generated codebase before it touches a real user. Step 1: Treat the AI Output as a First Draft, Not a Final Answer Say your AI assistant generates this login handler: \ javascript // AI-generated first draft app.post('/login', async (req, res) => { const { email, password } = req.body; const user = await db.query( SELECT * FROM users WHERE email = '${email}' ); if (user.password === password) { res.json({ token: generateToken(user) }); } }); \ \ Looks functional. It is also a SQL in

If you’ve spent any time poking around the AIE World’s Fair 2026 website, you may have come across...

The AI Engineer World's Fair here in San Francisco is fundamentally a conference for practitioners —...

Many of the sessions from Tuesday, especially on the main stage, revolved around the idea of software...

Crossword puzzles are easy. But what if you had to solve one while running inside the hardware constraints of a Large Language Model?

As you’d expect, the opening keynote of the AI Engineer World’s Fair was kicked off by one of its...

As AI agents work under increasingly less human supervision, the need for a trustworthy, secure work...

Software engineers have become overreliant on models to build applications, and it’s time to put...

What Claude Sonnet 5 Means for AI Infrastructure in East Africa The release of Claude Sonnet 5 on June 30, 2026 changes something specific about building AI agent infrastructure for regions like East Africa: the model tier that couldn't reliably finish a multi-step workflow now can. This isn't a general AI update note. It's about a concrete technical constraint that just moved. The constraint that moved East Africa's AI infrastructure problem isn't compute or APIs. M-PESA has an API. Africa's Talking has an API. NDMA publishes drought data. KRA has a taxpayer portal. The constraint has been that an AI agent calling several of these in sequence — check drought severity → trigger insurance evaluation → notify county — would stop partway through, lose context, or require manual handholding to continue. Sonnet 4.6, released in February, scored 67.0% on Terminal-Bench. Sonnet 5, released today, scores 80.4%. That 13-point gap isn't abstract. It's the difference between an agent that stalls at step two of a cascade and one that finishes. What this means for the East Africa coordination stack The 31 MCP servers in this portfolio — covering M-PESA, drought data, tax, credit scoring, crop insurance, land records, labor rights, county data, and more — are now meaningfully more useful as a system than they were yesterday. The key change: africa-coord-bus , the coordination event bus that connects these servers, is now the kind of tool Sonnet 5 was designed to orchestrate. A drought alert from wapimaji-mcp , cascading through bima-mcp for insurance evaluation and county-mcp for notification, is exactly the multi-hop tool chain where the 13-point Terminal-Bench improvement shows up in practice. The model to use # Claude API client = anthropic . Anthropic () response = client . messages . create ( model = " claude-sonnet-5 " , max_tokens = 1024 , tools = [...], # your MCP tools messages = [{ " role " : " user " , " content " : " ... " }] ) For compliance and vulnerability analysi

The problem every AI coding session hits You open Claude or Copilot, paste in your task, and immediately hit the wall: the codebase is too big. You either: Dump everything and burn 80% of your context window on irrelevant files Hand-pick files and miss the one import that breaks everything Pay for a bigger context window and repeat the problem at scale I got tired of this and built ContextOS — a local CLI that acts as an intelligent context layer between your repo and your AI agent. What it does pip install rm-contextos cd your-project contextos scan contextos pack --task "add rate limiting to the auth endpoint" --budget 8000 Output: a Markdown (or JSON) context pack with only the files that matter for that task — ranked by keyword match, import graph centrality, AST symbol overlap, and git churn. Secrets redacted automatically. Token savings report on every pack: Packed 12 files · ~6,840 tokens · saved ~47,200 tokens (87%) vs full repo How ranking works Five signals combine into a score per file: Signal What it catches Keyword match Files whose content/name overlap with your task Import graph centrality Files that everything else imports (critical shared modules) AST symbol overlap Function/class names, not just grep strings Git churn score Recently modified files are probably active code Secret penalty Credential files silently excluded No LLM calls. No cloud. Fully offline. MCP server (for Claude Desktop / Claude Code) pip install "rm-contextos[mcp]" contextos serve --stdio Register in claude_desktop_config.json and your AI agent can call pack_context , scan_repo , list_files , get_file , churn_report directly as tools — no CLI needed. What's shipped 980 tests, 96% coverage Apache-2.0, no telemetry, no accounts Python 3.11–3.13, Linux + macOS Export formats: Claude, Codex, Cursor, Aider, JSON Incremental scan cache — re-scans only changed files pip install rm-contextos pip install "rm-contextos[mcp]" # + MCP server pip install "rm-contextos[all]" # everything Git

The Gemini macOS app now has access to Google's Spark agentic AI assistant.

从思想到工程：FROST 与 FROST-SOP 的双生之旅 你知道吗？每一个伟大的工程背后，都有一个简单而深刻的起点。 引言：从 500 行到 5000 行的演进 在开源世界里，我们见过太多"大而全"的框架——它们功能丰富，却让人望而生畏。今天我想分享一个反其道而行之的项目： FROST 。 FROST （Fractal Runtime of Orchestrated Skills & Tasks）最初只是一个 500 行的教学框架，用最朴素的代码讲述 Agent 的本质。它的核心哲学只有一句话： 细胞会死，但谱系会存续。Agent 会消亡，但宪法会传承。资产会永存。 而今天我要介绍的，是 FROST 思想"开花结果"后的工程实践—— FROST-SOP ，一个拥有 5000+ 行代码的完整 Agent 工程平台。 FROST：理解 Agent 的钥匙 FROST 不是什么复杂的框架。它的设计哲学是 最小原子集 + 分形宪法 ： 四个原子，理解一切 原子 职责 生物学类比 Store 记忆容器，只做 save/load/delete 细胞核 Skill 纯能力单元，无状态无副作用 蛋白质 Agent 膜包裹的细胞，拥有 Store + Skills 神经细胞 SOP 有序步骤列表，可教学、校验、优化 宪法文本 from core import Store , Agent , skill_set , skill_get store = Store () agent = Agent ( " cell " , store , skills = { " set_context " : skill_set , " get_context " : skill_get }) result = agent . run ( sop_steps = [ " set_context " , " get_context " ], initial_context = { " key " : " message " , " value " : " FROST is alive " } ) # result["_result"] == "FROST is alive" 5 行代码，你就能理解整个 Agent 系统的运作原理。这就是 FROST 的魔力—— 用最少的代码，讲述最深的道理 。 五维元模型（V4.0/V5.0） FROST V4.0 引入的五维元模型，将框架从扁平升级为多维度 Agent 编排系统： 武器注册表 ：能力的元数据管理与发现 任务注册表 ：DAG 任务编排与图谱 SOP 事件编目 ：态势感知与双模式事件分析 平台注册表 ：外部能力的发现、调用与健康检查 规则注册表 ：可版本化的治理约束与合规检查 197 个测试用例保障质量，最新 Release： FROST v5.0.0 FROST-SOP：思想的工程化 FROST 教会我们理解，FROST-SOP 教会我们构建。 事件驱动的 Agent 家族 FROST-SOP 实现了完整的 祖辈 → 父辈 → 子辈 三层递归架构： import asyncio from core.event_bus import get_async_event_bus , Event , EventType from agents.ancestor import create_ancestor from agents.parent import create_parent async def main (): bus = get_async_event_bus () # 创建事件驱动的 Agent 家族 ancestor = create_ancestor ( constitution , asset , event_driven = True ) parent = create_parent ( " parent-1 " , store , event_driven = True , asset_store = asset , sop_id = " DEV-001 " ) # 发布任务，Agent 家族自动响应 await bus . publish ( Event ( event_type = EventType . TASK_CREATED , source = " user " , data = { " task_id " : " task-001 " , " task_description " : " 开发一个用户登录功能 " } )) await asyncio . sleep ( 10 ) asyncio . run ( main ()) 完整的工程特性 特性 说明 19 个内置 Skill