标签：#Agents

What nobody tells you about exporting your multi-agent prototype to a local workspace. Every architect who's prototyped a multi-agent app in Google AI Studio eventually hits the same wall: the prototype works, but it lives in a browser tab. At I/O 2026, Google shipped a fix — Export to Antigravity, a one-click handoff to a local production workspace, carrying "all the context" with it. I ran a real two-agent prototype through it. Here's exactly what survived the trip, what didn't, and what I had to fix by hand — including a bug that had nothing to do with the export itself. 1. The Pilot Project + The Click The project: Research Digest — a sequential two-agent app. Agent 1 (Researcher) takes a topic, uses grounded web search to gather sources. Agent 2 (Editor) synthesizes those findings into a polished digest. Persistence via Firestore, with a history archive of past digests. Built entirely from a single prompt in AI Studio's Build mode . Along the way, provisioning Firestore surfaced my first real gotcha before I even got to the export step — more on that below. Triggering the export: Code tab → Export → Export to Antigravity. The dialog is genuinely informative — it tells you upfront what's coming: all project files, conversation history, and explicitly "1 secret will be included." 2. What Actually Survives the Trip The export dialog's claims, checked one by one: Claimed to transfer What I found All project files ✅ Confirmed — full structure landed intact: .agents, .antigravity, src, config files, README.md with setup instructions Secrets (1 secret) ✅ Confirmed — GEMINI_API_KEY arrived populated in .env, worked immediately, no manual re-entry Conversation history history❌ Did not transfer. The imported "Research Digest" project showed "No conversations yet" in Antigravity's Agent Manager, despite the dialog's explicit promise. Checked twice, on two separate screens — consistent result. 3. The Gotchas Gotcha 1 — "Conversation history will carry over" is currently no

There's a pattern I kept seeing. A team gives an agent real capability, like moving money, shipping a change, or resolving a ticket that touches a customer's account. For a while it's great. Then the agent does one thing nobody can explain or defend after the fact, and the entire program snaps back to a human clicking approve on everything. The blocker was almost never the model. It was that there was no clean way to do two things at once. You couldn't bound what the agent was allowed to do before it acted, and you couldn't prove what it did after, in a form that survives contact with an auditor, a regulator, or a customer dispute. You can assemble that from parts today. Use a policy engine to authorize, and an audit log to record. The problem is they're two systems, and two systems drift. Six months later, when someone is actually asking "was this action allowed, and can you prove it," the policy engine and the log disagree about what the policy even was at the time. Now you're reconstructing intent from two sources that were never the same object. That's the gap. Not authorization by itself, and not observability by itself. The thing that authorizes an action and the thing that proves it should be the same object, bound to the exact policy version in force when the decision was made. The primitive Two verbs, one primitive. Control before. You mint a capability, which is a policy scoped to one agent: a spend cap, a counterparty allowlist, an expiry, whatever the action needs. Every consequential action the agent takes gets checked against the committed policy state and returns an allow or deny in the request path. An over-budget or out-of-policy action is refused before it happens, not flagged after. Refused is the operative word. The enforcement point commits no state change for a denied action, no matter how the agent reasons, how it's prompted, or whether it's been compromised. You've turned unbounded irreversible harm into bounded irreversible harm. Prove after

TLDR; I got tired of babysitting N terminal tabs of five different coding-agent CLIs. So I built agentproto — one daemon that drives Claude Code, Codex, Hermes, opencode, and Mastra through the same lifecycle, and actually supervises them. Why I built a daemon to drive every AI coding agent from one interface I have a confession: at any given moment I have Claude Code, Codex, and Hermes running in parallel terminal tabs, and I cannot remember which flag spawns which, which one eats --prompt , which one needs --cwd vs cd , and which one will hang forever if I close the laptop lid. simonw described the feeling on Hacker News recently — "Today I have Claude Code and Codex CLI and Codex Web running, often in parallel" — and called it a real jump in cognitive load compared to a year ago. aantix asked, also on HN: "how does everyone visually organize the multiple terminal tabs open for these numerous agents in various states?" I didn't have a good answer. So I built one. It's called agentproto . It is one daemon and one CLI that drives any coding-agent CLI — Claude Code, Codex, Hermes, opencode, Mastra, and a few more — through the same start / prompt / monitor / kill lifecycle, so you stop memorizing five different CLIs. On top of that lifecycle it adds the supervision layer people keep hand-rolling by hand: durable policy gates, nested orchestration, and multiplexed fan-in monitoring. MIT, no paid tier, the daemon itself is an MCP server. This is the story of why it exists. The hand-rolled watchdog The sharpest signal while I was building this came from other people independently re-inventing the same primitives in tmux scripts. On r/ClaudeAI, Confident_Chest5567 posted a writeup of orchestrating agents via tmux panes with a watchdog that resets dead sessions — "a swarm of agents that can keep themselves alive indefinitely." In the same thread, IssueConnect7471 (18 upvotes) described wiring a Redis pub/sub heartbeat plus dead-letter respawn between tmux panes, and arriv

Autonomous agents are starting to trade real money on-chain. Some run their creator's capital, some run other people's, some are wired into vaults and DAO treasuries. The moment money is delegated to a program, two questions matter more than performance: what was it allowed to do, and did it stay inside those limits? Supported chains: Base · Ethereum · Arbitrum · Optimism · Polygon · Hyperliquid · Solana (beta). The chain answers the first question badly and the second not at all. Every trade an on-chain agent makes is public and tamper-evident — you can see exactly what it did. But nowhere on-chain is it recorded what it was authorised to do . The mandate — the rules the agent was supposed to operate under — lives off-chain, unverifiable, usually as a screenshot or a claim. Why this is not a niche problem Copy trading is the same gap at retail scale, and the data is unforgiving. In a 90-day study of 100,236 copy-trading outcomes, 97% of lead traders were profitable on their own PnL — but only 43.6% produced positive PnL for the people copying them. Fewer than half of copiers (48.5%) finished in profit at all. Leaderboards, as that study puts it plainly, show the survivors, not the full picture. The honest response the industry already reaches for is third-party verification: in forex, platforms like Myfxbook exist precisely because a self-reported track record is worth nothing — the data has to come from somewhere the trader can't fake. Crypto has no equivalent that is both agent-native and tamper-evident. That is the hole. Who actually needs this Three groups, concretely: Anyone allocating capital to an agent — a vault depositor, a copy-follower, an allocator sizing a position. They want to see, before they commit, whether an agent keeps to its stated mandate, instead of trusting a screenshot. Anyone running an agent who needs to raise capital or followers — an honest operator has no way today to prove their agent did what it said. A verifiable record is how they

AI founders love the glamorous agent stories: coding agents, sales agents, AI doctors, AI lawyers. But if you dig through the YC 2026 batch data, one of the more interesting signals is decidedly unglamorous: insurance . Out of 477 real-ish company records in the current snapshot, 25 match insurance-related keywords — about 5.2% — and 8 companies sit in the Fintech → Insurance subindustry. Not a tidal wave. But it's enough to suggest something worth paying attention to: insurance is quietly becoming one of the better wedges for AI agents that actually ship. The reason is simple. Insurance is wall-to-wall documents, rules, judgment calls, exceptions, approvals, claims, underwriting, and cross-system coordination. In other words: wall-to-wall work that agents can do and humans hate doing. Insurance is not fintech's leftover category Most people file insurance under "slow fintech": aging distribution, legacy systems, long processes, heavy regulation. From an AI builder's perspective, that list of flaws reads more like a list of opportunities. Insurance workflows are highly structured — but not fully structured. Policies, claims files, medical records, photos, repair estimates, payout history, compliance clauses: the inputs are messy and heterogeneous. Yet every step has a crisp objective: is this covered, what documents are missing, how should this risk be priced, can this pass approval. That's not a chatbot problem. It's an agent problem — reading documents, following procedures, calling systems, leaving audit trails, handling exceptions. And precisely because it's complex, insurance is more likely to command real budget than yet another AI writing tool. Agents die without boundaries; insurance comes with them built in The most common failure mode for early agent products: they sound like they can do everything and end up doing nothing well. Insurance workflows hand you boundaries for free: Inventory and asset processes can be automated end to end Medical prior authori

WebMCP Runs In Chrome. My 400 Daily Tool Calls Don't. Google I/O 2026 shipped WebMCP and half the AI Twitter timeline is calling it "the new MCP standard." It isn't. It's a browser-scoped protocol that solves a completely different problem than the MCP servers currently running on your VPS at 3 AM. Here's the boundary Google buried in the docs, and how to decide which side of it your agent belongs on. What WebMCP actually is (and isn't) WebMCP is a browser-scoped tool protocol. It exposes tools to an agent from inside a Chrome tab — the tools live in the page, auth is the user's active session, and the runtime is the browser itself. That's the entire surface area. When Google says "agentic web," they mean an agent that operates inside a tab the user already has open, using the cookies and OAuth tokens already loaded. That's a legitimate and useful pattern: Booking flows — agent fills a multi-step form on a site the user is signed into Dashboards — agent pulls a chart, exports it, drops it into a doc In-app copilots — SaaS product ships tools its own users' agent can call Form fillers and page-scoped assistants What WebMCP is not : a replacement for the stdio and HTTP MCP servers running headless on your machine or VPS. Different runtime, different auth model, different lifecycle. Calling it "the new MCP" is like calling a service worker "the new backend." Same protocol family, entirely different deployment target. The split that actually matters There's exactly one question you need to answer to pick correctly: Is a human looking at a screen when the agent runs? If yes → WebMCP is on the table. If no → you need a real server-side MCP. That's it. Everything else is retweet noise. Dimension WebMCP stdio / HTTP MCP Runtime Chrome tab Your process (local, VPS, container) Auth User's browser session Your API keys / OAuth tokens Trigger User action in the page cron, webhook, queue, schedule Lifecycle While tab is open 24/7 headless Credentials scope Whatever the user is l

From answering questions to solving problems — Phase 6 of the Jarvis AI Platform After Phase 5, Jarvis could hear, speak, remember conversations, retrieve documents, and use tools. But every interaction was still limited to a single request and a single response. You: "What's the weather in Kathmandu?" Whisper ↓ AiOrchestrator ↓ WeatherTool ↓ Text-to-Speech Jarvis: "It is 22°C and clear." That works well for simple questions. It completely breaks down when a task requires multiple decisions. The Limitation of Single-Turn AI Imagine asking: Research the top 3 Java AI frameworks, compare them, and summarize the findings. A traditional chatbot usually replies: I don't have enough information to research that. The problem isn't intelligence. The problem is planning. To answer properly, the AI must: Search for Java AI frameworks Search for comparisons Gather information Analyze results Produce a summary That requires multiple tool calls and reasoning between each one. This is exactly what AI agents are designed to do. What Is the ReACT Pattern? ReACT stands for: Reason + Act Instead of generating one response, the AI repeatedly performs a reasoning loop. THINK ↓ ACT ↓ OBSERVE ↓ THINK ↓ ACT ↓ OBSERVE ↓ FINAL ANSWER Example: THOUGHT: I should search for Java AI frameworks. ACTION: search INPUT: Java AI frameworks 2026 ↓ OBSERVATION: Spring AI LangChain4j Semantic Kernel ↓ THOUGHT: Now I need comparison data. ↓ ACTION: search INPUT: Spring AI vs LangChain4j ↓ FINAL ANSWER Instead of guessing everything up front, the AI gathers information step by step before producing the final response. The Biggest Architectural Decision The most important design decision of Phase 6 was not modifying the existing chat pipeline . Instead of turning AiOrchestrator into a giant class responsible for both chat and agents, agents became a completely separate orchestration layer. ❌ Wrong AiOrchestrator ↓ Single Chat ↓ Agent Logic ↓ Tool Logic ↓ Everything Mixed Together ✅ Correct AgentController

用 FROST 五维元模型构建可治理的多 Agent 系统：从零到一的代码教程 作者 ：FROST Team 日期 ：2026-07-09 主题 ：代码教程 | 周四轮换 项目 ：FROST + FROST-SOP 前言 2026 年，Agent 框架百花齐放——LangChain、CrewAI、AutoGen 各有各的好。但它们都有一个共同的盲区： 治理能力 。 当你的 Agent 系统从 1 个变成 10 个，从跑 Demo 变成跑生产，你会发现： 谁有权做什么？没有答案 这个决策是谁做的？无法追溯 Agent 越权了怎么办？事后才能发现 FROST（Fractal Runtime of Orchestrated Skills & Tasks）的 五维元模型 就是为解决这些问题而设计的。 今天这篇教程，我们用代码从零构建一个完整的多 Agent 治理系统。 FROST （教学框架）提供理论基础 → Gitee 仓库 FROST-SOP （工程平台）提供工程落地 → Gitee 仓库 一、五维元模型是什么？ FROST V4.0 引入了五个核心维度，每个维度解决 Agent 治理的一个关键问题： 维度 模块 解决的问题 类比 武器 Armory Agent 有哪些能力？ 武器库清单 任务 TaskRegistry 工作如何编排？ 作战计划 事件 EventCatalog 发生了什么？ 战场态势 平台 PlatformRegistry 外部资源在哪？ 后勤补给 规则 RuleRegistry 什么能做/不能做？ 交战规则 五个维度 各自独立又相互咬合 ——就像五角星的五个角，缺一个就不完整。 二、环境搭建 # 克隆 FROST 教学框架 git clone https://gitee.com/liao_liang_7514/frost.git cd frost # 安装依赖 pip install -r requirements.txt # 验证环境 python -m pytest test_core.py -v FROST 的设计哲学是 零外部依赖 ——核心只需要 Python 标准库。五维元模型的模块也遵循这个原则。 三、维度一：Armory（武器注册表） Armory 管理 Agent 所有能力的元数据。不是简单的方法注册，而是带元信息的 能力目录 。 from core.armory import Armory , SkillMetadata # 创建武器库 armory = Armory () # 注册一个技能（带完整元数据） armory . register ( SkillMetadata ( name = " summarize_text " , category = " nlp " , description = " 将长文本压缩为摘要 " , input_schema = { " text " : " string " , " max_length " : " int " }, output_schema = { " summary " : " string " }, cost_estimate = 0.002 , # 每次调用预估成本 latency_ms = 500 , # 预估延迟 tags = [ " summarization " , " compression " ] ) ) armory . register ( SkillMetadata ( name = " search_web " , category = " retrieval " , description = " 联网搜索获取最新信息 " , input_schema = { " query " : " string " , " top_k " : " int " }, output_schema = { " results " : " list[dict] " }, cost_estimate = 0.01 , latency_ms = 2000 , tags = [ " search " , " real-time " ] ) ) # 发现可用技能 nlp_skills = armory . discover ( category = " nlp " ) print ( f " NLP 技能: { [ s . name for s in nlp_skills ] } " ) # 输出: NLP 技能: ['summarize_text'] # 按标签发现 search_skills = armory . discover ( tags = [ " real-time " ]) print ( f " 实时技能: { [ s

The AI race is quietly changing Months ago, most discussions revolved around one question: "Which model is the smartest?" Today, I'm seeing a different pattern. The conversation is shifting toward: How do we orchestrate multiple models, tools, and workflows effectively? Look at where the industry is investing. It's no longer just about improving the model itself. The focus is increasingly on long-running tasks, delegated execution, tool use, coding assistants, planning, memory, and specialized sub-tasks working together. That's not a coincidence. The model is becoming one component of a much larger system. As engineers, we're spending less time debating benchmarks and more time designing the layer around the model: • Context management • Routing requests to the right model • Memory and continuity • Tool orchestration • Verification and evaluation • Recovery and fallback strategies This is why I believe the next competitive advantage won't simply be having access to the "best" LLM. It will be building the best AI Harness—the engineering layer that coordinates models, tools, context, and decision-making into a reliable system. Cloud computing went through a similar evolution. Eventually, the infrastructure became a commodity, while orchestration became the differentiator. I think AI is heading down the same path. In a few years, we may stop asking: "Which model are you using?" and start asking: "What's your orchestration architecture?" I'm curious—are you seeing the same shift in your AI workflows, or do you think model capability will remain the primary differentiator?

AI coding agents are becoming good enough to touch real codebases. They can refactor files, write tests, change architecture, move logic around, and sometimes modify more code in ten minutes than a human would in an afternoon. That is powerful. But it creates a new debugging problem. Git can tell you what changed . When an AI agent was involved, you often need to know something deeper: Why did this change happen? Which prompt caused this line? Which model produced it? What files did the agent read before writing it? What later changes depended on this agent action? That is the problem I wanted to solve with Causari . Causari is a local CLI for intent-addressable code . It records AI agent actions as causal events: prompts, models, reads, writes, diffs, reasoning, cost, and relationships between actions. The goal is simple: Git tracks bytes. Causari tracks intent and causality. Repository: https://github.com/croviatrust/causari Website: https://causari.dev The problem When a human developer changes code, there is usually some context. A commit message. A pull request. A ticket. A discussion. A design decision. With AI coding agents, the workflow is different. You ask something like this: Refactor the auth flow and add JWT refresh logic. The agent reads files, makes assumptions, writes code, maybe fixes tests, maybe changes something unrelated, then moves on. At the end, you have a diff. But the diff does not tell the full story. A suspicious line appears in auth.ts . Git can show when the line appeared. But Git cannot answer: which prompt produced this exact line? what completion did it come from? did the agent read the right files first? was this part of the original request or an accidental side effect? if I revert this, what downstream work am I also undoing? That gap becomes bigger as agents become more autonomous. The more work agents do, the more we need provenance. Not only code provenance. Intent provenance. The idea: intent-addressable code Causari treats an

I tried to build an arbitrage bot between Kalshi and Polymarket. Sports seemed to be the easiest because the matcher is relatively easy compared to the other markets (economy, bitcoin, weather, etc.) The matcher worked, we got about ~98% of the sports and e-sports market. But there's barely any sizable arbitrage between Kalshi and Polymarket, and what shows up closes in under 10 seconds. For the Argentina vs Egypt, the match with the disputed VAR call and Argentina's stoppage-time comeback from two goals down. Every price swing on that match, including the two around the VAR call, closed inside about 45 seconds. Total arbitrage opportunity net of fees across the whole match: $439, against $20.8 million moving through Polymarket's market alone and $13.8 million in Kalshi open interest. ( https://dino.markets/blog/argentina-egypt-var-price-gap ) That's not an arbitrage opportunity. That's what an efficient pair of order books looks like once you finally have the tooling to watch them at the same time. I logged this properly over a full day too: 870 cross-venue price gaps in one 24-hour window, median time open about 9 seconds, 96 percent closed inside 30. ( https://dino.markets/blog/how-long-a-mispricing-lasts ). So I shipped the Polymarket-Kalshi sports market matcher as an API instead of an arbitrage trading bot. It turned out the matcher itself was the useful part. Free REST access to the matched feed and the confirmed-arb view, 60 requests a minute, MCP server included so an agent can read it without you writing a client. Planning to open source the matching engine itself at some point. After that, either extend it to other market pairs between Kalshi and Polymarket, or look at arbitrage against traditional sportsbooks. Nothing locked in yet. Feel free to use it and tell me what you think about it. Thanks!

Itamar Friedman discusses how architects and engineering leaders can break through the AI productivity ceiling using adaptive multi-agent systems. He shares insights on moving past simple autocomplete to resilient workflows by integrating autonomous testing, intelligent code review, and robust arbitration. Learn how to govern agent communication and build a context-driven SDLC that scales. By Itamar Friedman

In the world of project management and team collaboration, the holy grail is reducing friction. Previously, we looked at how to make Trello cards talk back The Power of Gemini inside Trello and how to bring Gemini into your workspace Gemini in your Slack workspace . But what if you wanted a highly intelligent, stateful team assistant living directly in Slack that could answer complex, open-ended questions about your Trello boards? Questions like: "Which cards did I edit last week?" "Show me all comments made across my active boards in the last 7 days." "What is the current status of the card XYZ?" Answering these questions requires more than simple semantic search; it requires a tool that can dynamically write retrieval scripts, parse complex multi-board JSON payloads, filter dates, and compile elegant reports. In this article, we'll explore how to build exactly that using Google’s Antigravity Managed Agent (the "Agy" agent) , integrated into Slack's native Agent View , utilizing a secure, stateful, and sandboxed remote execution environment. 🚀 Prerequisites Before starting, make sure you have: A Google AI API Key with Gemini / Antigravity access A Trello Account (with an API Key and Token for read-only board queries) A Slack Workspace (with App Admin privileges to create a Socket Mode app) Node.js (v24+) and pnpm (v11+) installed 🔒 Security & Environment Controls: The Agy Sandbox Philosophy At the heart of this setup is Google's Antigravity (Agy) Managed Agent . Instead of running in a transient stateless environment, the Agy agent operates inside a persistent, secure, and remote Linux sandbox equipped with standard execution engines (Python, Node.js, bash, etc.). When a Slack user asks a question, the Agy agent dynamically writes a script, runs it in its isolated sandbox, inspects the Trello API output, self-corrects if any errors occur, and presents a formatted response. In this article, we focus on Trello, but the same principles can be applied to any other syst

Enterprises are now talking about AI coding agents in a very predictable way. The first question is usually: "How much more code can it help us generate?" It is not a wrong question. But if that is the only question, the ROI calculation will probably be wrong. Because enterprises are not really buying "more code." They are buying: faster delivery less rework lower maintenance cost better developer experience more stable software quality more controllable security and compliance risk faster translation from product capability to business value Code generation is an input. It is not the outcome. That distinction matters. An AI coding agent can help developers write functions, fix bugs, add tests, generate documentation, understand codebases, and refactor legacy systems. That sounds powerful. But the enterprise question is not: "How many lines of code did it generate today?" The better question is: Did that code reach production faster? Did incidents go down? Did the team spend less time on repetitive work? Did customers get value sooner? If the answer is unclear, generating 100,000 lines of code a day may simply mean producing technical debt faster. The short version: AI coding agent ROI does not end inside the IDE Many teams start measuring AI coding tools with the most obvious numbers: code suggestion acceptance rate lines of code generated number of active users number of prompts time saved on individual tasks These metrics are useful. But they mostly show that the tool is being used. They do not prove that the enterprise is getting value. Enterprise ROI has to be measured across software delivery, quality, risk, and business outcomes. In other words, an AI coding agent is not just a point solution for individual efficiency. It affects the entire software value stream: Request -> Design -> Coding -> Review -> Testing -> Deployment -> Monitoring -> Feedback -> Business outcome If you calculate value only inside the "coding" box, you miss the bigger picture. Why "amo

I hate presenting. Not the prep, not the content, the actual moment of unmuting, sharing my screen, and narrating 20 slides to a wall of black camera squares, having no idea if anyone's actually listening or just quietly making lunch. So a couple weekends ago I went down a rabbit hole and built something to get me out of that. It's called Meeting Presenter. It's an AI skill that joins the call and presents the deck for you. You just... sit there. Steer it if you feel like it. Or don't. What it actually does You hand it a deck, it joins the meeting, shares its screen, and talks through the slides on its own. Not in a flat text-to-speech way either, it walks through the content more like a person explaining it than a bot reading bullet points. The part that actually got me hooked, though, wasn't the presenting, it's that you don't even need a finished deck to use it. If you've got a PowerPoint or PDF already, it'll just present that. If you've only got some rough notes, it'll turn those into slides first. And if you've got nothing but a vague idea, you can hand it a single sentence and it'll build the deck from scratch before presenting it. Which means the laziest possible version of this is: think up a topic five minutes before standup, type it in, and let it build and present the thing while you drink your coffee. I'm not proud of how often I've already done this. Setting it up Took me less than 10 minutes, most of which was making coffee while it installed. Grab a free API key from agentcall.dev - no lengthy signup, just a few seconds. Install it. Two options depending on how hands-on you want to be: Recommended: paste the GitHub repo link to your coding agent and tell it to install it. It clones and sets everything up for you. Or clone it manually and run it with your meeting link and deck. No config files to hand-edit. What it's actually like on a call It joins like any other participant, and it asks before it starts presenting rather than just barging in mid-mee

While working on the GitHub adapter, a gateway that lets AI agents create pull requests on GitHub, the source_state field first looked like a small technical detail. It was not the operation itself, or the target. It was only a reference to the state the agent had seen before proposing a change. But after working through the write path, this field started to look less like metadata and more like part of the safety model. A proposed change is not only defined by what it wants to do. It is also defined by the state in which that proposal made sense. This is easy to miss. An agent can read a repository, produce a reasonable change, and submit a clean intent. Nothing about that has to be wrong. But while the agent is planning, the repository can move. A human can push a fix. Another workflow can update the same file. A branch can advance. In that case, the agent may still be reasoning correctly over the state it saw. The problem is that this state no longer exists. The reasoning was right, but the world shifted. That is the stale state problem in agent workflows. And it is why I think agent workflows need state-bound intent. The illusion of a static world From the outside, even from the boundary's point of view, a stale request can look just like any other: the operation has the same name, the target path is still allowed, the input is still well formed. But it is not. The proposal belonged to an older state of the repository, formed before the branch moved, before the file changed, before another workflow created a related result. This is why stale state is not only a data freshness problem. For agent workflows, it becomes an admission problem: a decision about whether a proposed change is allowed to become a real effect. We call that decision point an MCP Boundary: the same pattern behind the GitHub adapter and the wider work we do on MCP gateways. The boundary should not only ask whether the operation is allowed on the target. It should also know whether the target i

Reading Lilian Weng's harness engineering survey as a reliability engineer — what self-improving harness papers actually show, and the three invariants every working loop converges on.

一个任务的奇幻漂流：同一个Agent任务，在FROST和FROST-SOP中分别长什么样？ 作者 ：神通说 日期 ：2026-07-08 主题 ：双项目联动 | 周三轮换 阅读时间 ：8分钟 一个问题 你可能听过这样的故事： "这个框架很好，但我不知道怎么用到真实项目里。" FROST 社区里也收到过类似的反馈—— "500行代码确实让我理解了Agent的本质，但理解完之后呢？怎么从'看懂'到'会用'？" 今天这篇文章，就用 同一个真实任务 ，分别展示它在 FROST 和 FROST-SOP 中的样子。你会发现：它们不是两个不同的东西，而是 同一个东西的不同分辨率 。 今天的任务：自动写日报 假设你是一个独立开发者，想让Agent每天自动帮你写工作日报。需求很简单： 收集今天完成的任务 用LLM生成日报摘要 发送邮件给自己 就这么三步。让我们看看它在两个项目中分别怎么实现。 第一站：FROST——用最少的代码理解本质 FROST 的哲学是： 先用500行代码告诉你Agent的底层逻辑，剩下的你自然就会了。 在FROST中，一个Agent的运作只需要四个原子： from core import Store , Agent , skill_set , skill_get # 1. 创建记忆容器 store = Store () # 2. 定义能力（Skill = 纯函数） def collect_tasks ( context ): """ 收集今日任务 """ tasks = [ " 完成FROST v5.0文档 " , " 修复Skill测试用例 " , " 写推广文章 " ] context [ " tasks " ] = tasks return context def generate_summary ( context ): """ 生成日报摘要（简化版，实际调用LLM） """ tasks = context . get ( " tasks " , []) context [ " summary " ] = f " 今日完成 { len ( tasks ) } 项任务： " + " 、 " . join ( tasks ) return context def send_report ( context ): """ 发送日报 """ context [ " sent " ] = True print ( f " [日报已发送] { context [ ' summary ' ] } " ) return context # 3. 组装Agent agent = Agent ( " daily_reporter " , store , skills = { " collect " : collect_tasks , " summarize " : generate_summary , " send " : send_report }) # 4. 用SOP编排执行顺序 result = agent . run ( sop_steps = [ " collect " , " summarize " , " send " ], initial_context = {} ) # 输出：[日报已发送] 今日完成3项任务：完成FROST v5.0文档、修复Skill测试用例、写推广文章 这段代码做了什么？ Store 是记忆——Agent的工作空间，所有中间结果存在这里 Agent 是细胞——拥有记忆和能力的最小执行单元 sop_steps 是宪法——定义执行顺序，Agent不会自作主张改变流程 就这么简单。没有配置文件，没有YAML，没有复杂的初始化。 30行Python代码，一个完整的Agent就跑起来了。 这就是FROST的价值——它不帮你"做"什么，它帮你 看懂 Agent到底是什么。 问题来了 上面的代码能跑，但如果你真的想把它用在生产环境，你会遇到一堆问题： 发邮件的能力怎么写？ FROST不管——它只告诉你Skill是纯函数，具体实现你自己来 LLM调用怎么复用？ 每次写日报都要调LLM，总不能每次都重写一遍 任务失败了怎么办？ 发邮件失败了，要不要重试？重试几次？ 执行日志在哪？ 老板问"今天日报发了吗"，你怎么知道发没发？ 多个Agent协作呢？ 一个人有好几个项目，每个项目一个Agent，怎么协调？ FROST对这些问题的回答是： 这些问题不是我该回答的。 但它的兄弟——FROST-SOP——就是专门回答这些问题的。 第二站：FROST-SOP——让同一个任务跑在生产环境 FROST-SOP 的哲学是： 把FROST教你的每一个概念，都变成生产级的工程组件。 同样的"自动写日报"任务，在FROST-SOP中长

You asked your AI to help you plan a trip. It gave you a paragraph about packing layers and booking early. You needed a checklist, a hotel shortlist, a flight window, and a rough daily schedule. What you got was a thoughtful non-answer dressed up as advice. That gap — between what AI tells you and what it could actually do for you — is the gap agentic AI is designed to close. And most people don't know it exists. The Difference Between Answering and Acting Standard AI models are trained to respond. You send a prompt, they generate a reply. The entire interaction lives inside a single text exchange. Agentic AI operates differently. Instead of producing one answer, it takes a goal and breaks it into a sequence of steps — then executes them, one after another, checking its own output along the way. It can look things up, organize information, write to a document, revisit a step if something doesn't look right, and deliver a final result that's actually usable. The travel example makes this concrete. A conversational model tells you to pack a rain jacket. An agentic setup builds you the trip: it pulls destination weather data, generates a packing list specific to your travel dates, identifies hotels in your price range, and drops everything into a structured itinerary. Same goal. Completely different level of output. Author's note: The word "agentic" has been overloaded to the point of meaninglessness in tech marketing. For our purposes here, it means one specific thing — an AI that runs a loop: think, act, observe the result, decide the next action. If it's not doing all four of those things in sequence, it's not really an agent. It's just a chatbot with extra steps. Why This Loop Changes Everything The reason agentic AI feels qualitatively different isn't magic — it's architecture. The core mechanic comes from a framework called ReAct (short for Reasoning and Acting), introduced in a 2023 paper by Yao et al. and now foundational to most production agent systems. The l

A lot of AI memory systems start with the same temptation: "Just save the useful thing." That sounds harmless until the knowledge base becomes a junk drawer. Half the notes are too specific, a few are duplicates, some are obsolete, and nobody knows which ones the agent should trust. In ai-assistant-dot-files , the memory system is deliberately slower. It uses a promotion lifecycle: Capture -> Candidate -> Audit -> Approve -> Index -> Retrieve -> Expire That lifecycle is documented in docs/runbooks/memory-engineering.md , and the important word is not "capture." It is "candidate." Nothing writes directly to memory The framework has a durable memory layer: Knowledge Items in shared/knowledge/ , ADRs in docs/adrs/ , the domain dictionary, team topology, a feature archive, and a registry at shared/memory-registry.json . But a lesson from a delivery does not jump straight into shared/knowledge/ . It first becomes a Candidate Record. That record has required fields: Source Type Evidence Tags Expiration condition Then memory-engineer audits it: Is it reusable? Is it already covered? Is it too speculative? Does it belong as a Knowledge Item, or should it become a rule change, prompt edit, or ADR instead? Only after that does a human approve the destination. The design is intentionally similar to code review. Durable memory changes future behavior, so they deserve a paper trail. Rejection is a feature One of my favorite parts of the memory runbook is that it has explicit rejection rules. Do not promote a memory when it is: a one-off already covered too speculative That makes "zero candidates promoted this cycle" a healthy result, not a failure. This is where memory engineering starts to look less like note-taking and more like gardening. The point is not to preserve every leaf. The point is to keep the soil useful. Expiration matters The lifecycle also includes expiration. A Knowledge Item can become stale when the underlying code, agent, or pattern changes. It can be supers