标签：#ai

This is part thirteen in a series about managing the growing pile of skills, scripts, and context that AI coding agents depend on. Part ten covered the full improve pipeline — all five phases and how they connect. Part fourteen covers what 48 runs per day looks like in practice, including hardware benchmarks and the reliability bugs that surface at that frequency. The reflect pass inside akm improve has three execution modes. Most installs are still running the slowest one. Agent mode — the original — spawns an opencode or claude subprocess for each reflect call. The subprocess starts cold, acquires a session, assembles context, makes its LLM call, and exits. That cold-start overhead is real: each call takes approximately 30 seconds on a quiet machine. Run akm improve against a 69-ref stash and the reflect phase alone costs about 35 minutes. SDK mode eliminated the subprocess. The reflect call runs in-process, cutting per-call latency to 10–15 seconds. A 69-ref run drops to 12–17 minutes — better, but still bounded by round-trip overhead that the reflect task does not actually need. LLM mode removes the round trip entirely. The context for reflect is statically pre-assembled — no live tool calls, no file reads, no external context needed. A direct HTTP call to the LLM endpoint is sufficient, and it costs 6–10 seconds per call. A 69-ref run completes in 8–10 minutes. Mode Per-call latency 69-ref run agent (CLI subprocess) ~30s ~35 min sdk (in-process) ~10–15s ~12–17 min llm (direct HTTP) ~6–10s ~8–10 min The 3–4× end-to-end improvement is from eliminating overhead that was never necessary for what reflect does. Why Reflect Does Not Need an Agent The reflect pass takes a stash asset, examines its current content, and proposes a refined version. The inputs are fixed before the pass starts: the asset text, its metadata, and the improvement prompt. Nothing changes mid-call. No files need to be opened. No search queries need to fire. No external context needs to be pulled

A self-improving memory loop sounds like a clear win until you watch it rewrite something correct with something outdated. The agent remembered a fact. You verified it. A later consolidation pass ran against a stale context window, decided the memory was imprecise, and replaced it with a weaker version. The original was better. You lost ground. This is the failure mode that belief-aware memory was built to prevent. Not "agents write wrong things" — that's a model quality problem. The specific failure is: the improve loop, running unsupervised, overwrites correct content it should have left alone. A loop that can degrade its own best work is worse than no loop at all. akm 0.8.0 ships captureMode and beliefState as first-class frontmatter fields on memory assets. Together they tell the consolidation pass what each memory is, what the agent believes about it, and whether it is eligible to be rewritten. The Two Capture Modes Every memory asset now carries a captureMode field. It has two values. hot means the memory was written or explicitly confirmed by a human. The improve loop treats hot memories as read-only. No consolidation plan, no merge proposal, no rewrite. If every memory in a chunk is captureMode: hot , the consolidation pass skips the LLM call for that chunk entirely — the chunk is counted as judgedNoAction before a single token is spent. This is the all-hot chunk early-exit. background means the memory was generated by an agent — promoted during a prior consolidation run, written by an inference pass, produced by akm remember without explicit human review. Background memories are eligible for improvement. The consolidation pass can propose merges, rewrites, deletions, or upgrades. When no captureMode is set, the memory is treated as eligible for consolidation. Memories that existed before 0.8.0 are treated this way on first encounter. --- captureMode : hot beliefState : asserted description : Primary LM Studio endpoint moved to Shredder (192.168.0.99:1234) -

This is part eleven in a series about managing the growing pile of skills, scripts, and context that AI coding agents depend on. Part nine covered workflow assets and resumable procedures. Part ten introduced the improve pipeline that continuously curates your stash. Earlier parts addressed teams, distributed stashes, and community knowledge. Most automation with AI agents is reactive. You open a session, give the agent a task, wait for the result, close the session. The agent's clock runs when you run it. Task assets flip that model. A task is a YAML file in your stash that defines a workflow — what to run, when to run it, what environment it needs, and how long it's allowed to take. Once registered, the task runs on schedule without your involvement. The OS scheduler calls akm tasks run <id> , which executes the task and writes the result to state.db . You find out what happened when you check akm health or look at the log. This is the piece of akm 0.8.0 that makes continuous operation possible. The improve loop runs twice an hour because a task asset says it does. The hourly Discord health report fires because a task asset says it does. Neither requires an open terminal. The Task Asset Format Task assets live at <stash>/tasks/<id>.yml . The filename is the task ID. A minimal task looks like this: schedule : 0 * * * * command : akm improve --auto-accept 90 enabled : true That's enough to install a cron entry and run akm improve at the top of every hour. The full schema adds metadata and per-task timeout control: schedule : " 7,37 * * * *" command : akm improve --auto-accept 90 --timeout-ms 1620000 enabled : true timeoutMs : 1800000 name : akm-improve description : Run the improve pass at :07 and :37 — reflect, distill, consolidate, lint, and eval. when_to_use : Twice per hour; leaves ~23 minutes of idle headroom between completions. tags : - improve - maintenance The fields that matter most: Field Required Purpose schedule yes Standard cron expression. Maps to cro

This is part ten in a series about managing the growing pile of skills, scripts, and context that AI coding agents depend on. Part nine covered workflow assets, vault assets, and the writable git stash. Part eight tackled multi-wiki support for structured research. Earlier parts addressed teams, distributed stashes, feedback scoring, and community knowledge. This one is about entropy. You ship a feature. Your agent writes several memories during the session — partial findings, a workaround, a note about the build step that kept failing. Those memories are accurate when written. Three sprints later, the workaround is no longer needed, two of the memories say slightly different things about the same subsystem, and the note about the build step refers to a CI config that was replaced. None of this is catastrophic. But it accumulates. After six months, a significant fraction of your stash is stale, redundant, or quietly wrong. You could audit it manually. In practice, you won't — the stash is too large, the relevance of any given memory is hard to assess without the context where it was created, and the judgment calls (merge these two? promote this? delete that?) are exactly the kind of work that's tedious for a human and tractable for an LLM. akm improve is the answer to that problem. It is a multi-phase pipeline that reads your stash, evaluates asset quality, consolidates scattered memories, extracts structured facts, and maps entity relationships — on a schedule, without manual intervention, producing proposals you can review before anything changes. The Five Phases akm improve is not a single LLM call. It is a sequenced pipeline where each phase produces inputs for the next. Reflect evaluates asset quality. For each asset in scope, the reflect pass reviews the content against usage signals — search hits, retrieval counts, feedback — and produces a quality assessment. Low-quality assets are flagged as candidates for improvement. Since 0.8.0, reflect can run as a dire

Nintendo is planning to launch versions of Switch 2 hardware in the EU that will let users easily replace the battery. To meet its obligations from a new EU regulation that's set to go into effect on February 18th, 2027, Nintendo says on its website that it is "implementing measures to comply with these requirements […]

An action plan for AI-powered biological resilience

Lovable and Google signed an expanded multiyear deal that involves a 5x expansion of Lovable's footprint on Google Cloud, and expanded access to Anthropic Claude.

A security firm called PromptArmor published a writeup on May 27, 2026 showing that ChatGPT for Google Sheets, an OpenAI extension with more than 185,000 downloads, could be made to steal a user's spreadsheets through a single ordinary-looking request. Four days later, on May 31, OpenAI shipped a fix. The short version is that one benign question, typed by a real user into a sheet that contained hidden instructions, was enough to drain twelve linked workbooks out of that user's account and replace the assistant with a fake phishing chatbot. I want to walk through how this worked, because the mechanism matters far more than the headline, and because the same shape of problem is going to keep showing up everywhere we bolt an AI assistant onto data we did not write ourselves. What happened The attack is a textbook indirect prompt injection. The user does nothing wrong. They import a sheet, or pull in data through a connector, and somewhere in that data sits a block of text the attacker controls. In the PromptArmor demonstration the malicious instructions were written in white text on a white background, invisible to a human skimming the sheet but fully readable to the model parsing the cells. When the user later asks the assistant a normal question, the model reads the whole context, including those hidden instructions, and treats them as if they came from the user. The injected text tells the assistant to fetch and run an external script. That script runs with the permissions the extension already holds, which means it can read the current workbook, find URLs to other workbooks linked inside it, and walk outward from there. PromptArmor reported it exfiltrating twelve workbooks in total from a single trigger, then dropping a fake chat interface on top to harvest whatever the user typed next. The detail that should bother you most is this line from their report: the attack succeeds even when the user has explicitly disabled automatic edits. The human-in-the-loop approva

Mutagen 0.4.0 addresses the friction points that plague agentic workflows: context bloat, brittle persona transitions, and the lack of a deterministic path from design document to deployed artifact. We aren't trying to make prompts smarter; we are making the harness that executes them more precise. This release introduces a Rust-based service extraction layer that decouples static dependency mapping from generative reasoning, implements an adversarial verification pipeline to gate deployment, and enforces strict stage transitions to prevent the agent personas we rely on from drifting into one another's scopes. The Service Extraction Layer: Decoupling Logic from LLM Context The primary bottleneck in current agentic stacks is token consumption. When a model attempts to reason about a codebase that spans multiple dependencies, it often spends its context window parsing file headers and resolving imports before it can actually write logic. This approach treats static infrastructure as if it were part of the reasoning problem. Mutagen 0.4.0 changes this by introducing a dedicated Rust layer designed to extract service definitions directly from your codebase without polluting the primary agent context. Instead of asking an LLM to map dependencies, the harness queries the local file system and executes static analysis routines. It isolates business logic execution from the generative reasoning loop used by Claude and Codex. This separation allows the model to focus on how to solve a problem rather than where the pieces are located. In practice, this means offloading static infrastructure queries to the harness rather than the LLM. The result is reduced latency and significantly lower token costs for complex applications. You get a dependency map that is as reliable as a compiler's parse tree, not a probabilistic guess from a prompt. // Example: Service extraction logic isolated from the reasoning loop fn extract_services_from_codebase () -> HashMap < String , Vec < Depende

Why Senior .NET Engineers Rarely Trust User Input Most beginner C## developers discover TryParse() while learning console applications. It usually appears during a simple exercise: Console . Write ( "Enter quantity: " ); string ? input = Console . ReadLine (); if ( int . TryParse ( input , out int quantity )) { Console . WriteLine ( $"Quantity: { quantity } " ); } At first glance, it looks like a convenience method. A safer version of Parse() . A small utility. Nothing particularly interesting. But experienced .NET engineers see something completely different. They see one of the earliest examples of defensive programming. Because software engineering is not about handling perfect input. It is about surviving imperfect input. And in production systems, imperfect input is the rule—not the exception. TL;DR TryParse() is not just a conversion method. It introduces some of the most important concepts in professional software development: Defensive programming Input validation Runtime safety Exception avoidance Financial precision Domain modeling Reliability engineering Understanding why TryParse() exists is often more valuable than learning how to use it. Every Value in C## Starts With a Type One of the first concepts developers learn is that every variable has a type. int quantity = 10 ; decimal price = 25.99M ; string productName = "Laptop" ; bool isAvailable = true ; Simple. Yet this idea is foundational. Because types are not just containers. They are contracts. Each type defines: Valid values Memory layout Available operations Precision guarantees Runtime behavior When you choose a type, you are making an architectural decision. Why decimal Exists Many developers ask: Why not use double for money? Because financial systems require precision. Consider: double a = 0.1 ; double b = 0.2 ; Console . WriteLine ( a + b ); Expected: 0.3 Reality: 0.30000000000000004 The issue comes from binary floating-point representation. For scientific calculations, this is acceptable. F

这视频由知名半导体分析机构 SemiAnalysis 发布，围绕 AI 数据中心网络演进中铜（Copper）与板载共封装光学（CPO - Co-Packaged Optics）的竞争和未来进行了极其硬核且详细的深度拆解。 视频的核心逻辑可分为以下几个关键板块： 一、 背景：铜的物理极限与三大网络层级 1. 铜的物理极限 视频开篇强调，半导体一直依赖铜（如芯片金属层、主板走线、NVL72机架的背板总线）。但当单通道传输速率达到 200 Gbits/second (每路) 及以上时，铜的传输距离极限被死死卡在 2米以内 [ 00:55 ]。超过这个距离，现代 AI 服务器的庞大带宽需求就只能依赖光纤和激光 [ 01:01 ]。 2. AI 数据中心的三大网络层级 [ 01:43 ] 前端网络（Front-end Network）： 负责基础的数据加载、SSH 访问和用户请求，带宽要求最低 [ 01:51 ]。 纵向扩展网络（Scale-up Network）： 连接单机架内的所有计算和网络托盘（如英伟达的 NVLink），让多张 GPU 能以极高带宽、极低延迟像“单张 GPU”一样协同工作 [ 02:07 ]。其带宽需求是 Scale-out 的 10 倍 [ 03:47 ]。 横向扩展网络（Scale-out Network）： 负责机架与机架之间、甚至整个数据中心范围内的服务器互联 [ 03:00 ]。其带宽需求是前端网络的 8 到 10 倍 [ 03:47 ]。 二、 传统可插拔光模块（Pluggable Transceivers）的致命痛点 在需要跨机架的 Scale-out 网络中，目前行业标配是可插拔光模块（如 OSFP、QSFP-DD） [ 04:29 ]。 视频拆解了它的四大组成部分： 物理接口、DSP（数字信号处理器）、TOSA（激光发射组件）、ROSA（光接收组件） [ 05:03 ]。 视频提出了一个颠覆直觉的事实： 耗电和延迟的元凶根本不是激光器（仅占15%功耗），而是 DSP。 [ 06:06 ] 功耗： DSP 消耗了光模块高达 60% 以上 的电能 [ 06:21 ]。 延迟： 信号从电转换到光通常会带来 150 到 200 纳秒的延迟，其中 90% 以上由 DSP 造成 [ 06:28 ]。 为什么必须要 DSP？ 因为 GPU 或交换机生成的电信号，在穿过芯片封装、主板走线到达机架边缘的光模块（约 30 厘米距离）时，信号已经严重衰减和失真，必须通过 DSP 进行放大和“清洗” [ 07:17 ]。而 CPO 的核心存在意义，就是将光学引擎无限靠近源头，彻底消灭 DSP [ 06:57 ]。 三、 从 LPO 到 CPO 的技术演进路径 为了干掉 DSP，行业尝试了多种方案： LPO（线性可插拔光模块）： 做法很大胆，直接拿掉可插拔模块里的 DSP，强行把失真的电信号转成光信号发出去。虽然有用，但极大牺牲了传输距离 [ 08:25 ]。 OBO（板载光学）： 把光模块从机架边缘移到主板上更靠近芯片的位置。但由于距离还不够近，没能彻底干掉 DSP，同时还丢掉了可插拔的便利性，宣告失败 [ 09:06 ]。 NPO（近封装光学）： 将光学引擎移至与 ASIC（交换机芯片/GPU）极近的特殊高特性基板上，是目前正在落地的折中方案 [ 09:38 ]。 CPO（共封装光学）： 终极形态，将光学引擎与芯片直接封装在同一个 Package 上 [ 10:01 ]。 视频中拆解的 CPO 三大阶梯（Tiers）： 第一阶梯（最低限度）： 光学引擎与交换机芯片在同一封装基板上，通过铜走线连接。虽干掉了 DSP，但仍需要 SerDes 进行并行/串行信号转换 [ 10:31 ]。 第二阶梯（中介层集成）： 芯片与光学引擎坐落在同一个硅基或有机中介层（Interposer）上，互连密度大幅提升， 彻底不再需要 SerDes ，实现完全的并行集成 [ 11:01 ]。 终极 Boss 级： 利用混合键合（Hybrid Bonding）等 3D 堆叠技术（2.5D 如台积电的 COW-AMH），将光学引擎直接叠在芯片上方或下方，实现极致的低功耗 [ 11:31 ]。 四、 CPO 的商业落地博弈：Scale-out 网络 CPO 的首个落地目标是替代 Scale-out 网络中的传统光模块 [ 12:46 ]。然而，行业对此产生了严重分歧： 传统可插拔的优势： 坏了极易更换（运维成本低）；标准统一、供应商极多，大厂拥有极强的 价格控制权 且能避免 供应商锁定（Vendor Lock-in） [ 13:29 ]。 CPO 的软肋： 它是封装级别的。如果你买英伟达或博通的 CPO 芯片，你就必须绑定购买他们的整套光学方案；一

Gemma 4 12B Multimodal, AI Copilot Selection, & AI-Optimized Documentation Strategies Today's Highlights Today's top stories delve into a new foundational multimodal AI model, strategic selection of AI copilots for productivity, and practical techniques for creating documentation suitable for both human readers and AI assistants. These insights are crucial for developers building and deploying advanced AI solutions in real-world workflows. Gemma 4 12B: A unified, encoder-free multimodal model (Hacker News) Source: https://blog.google/innovation-and-ai/technology/developers-tools/introducing-gemma-4-12b/ Google has announced Gemma 4 12B, marking a significant step forward in multimodal AI. This model distinguishes itself with a "unified, encoder-free" architecture, simplifying the process of handling diverse data types such as text and images without the need for separate encoding layers. This architectural innovation promises more efficient training, reduced inference costs, and improved coherence in understanding and generating content across different modalities. For developers, Gemma 4 12B provides a robust and flexible foundation for building sophisticated AI applications. It enables the creation of intelligent systems that can process and respond to complex queries involving various input formats, from intelligent search and content generation to advanced human-computer interaction. This streamlined approach to multimodal processing is critical for developing next-generation AI tools and frameworks. Comment: An encoder-free, unified multimodal architecture for Gemma 4 12B is a big deal for reducing complexity and improving cross-modal understanding. This model could significantly simplify building AI applications that need to process and generate content across text and images efficiently. Presentation: Choosing Your AI Copilot: Maximizing Developer Productivity (InfoQ) Source: https://www.infoq.com/presentations/choosing-ai-copilot/?utm_campaign=infoq_content&

Google must change AI Overviews after claiming users don't want "lots of sources."

If Alphabet's record-breaking $85 billion stock sale signals investor appetite for AI-related offerings, we can see that investors are ready to chow.

Gemma 4 12B uses a new encoding scheme and token prediction to punch above its weight.

Dreambeans is a curated list of AI-illustrated "stories" culled from the personal data in your Google account.

Most teams don’t have a documentation shortage. They have a context shortage. The average developer spends 20 minutes hunting for context before a one-line change. Their AI pair-programmer spends that same time hallucinating. I’ve been thinking a lot about what documentation actually needs to become in an AI-assisted world. The answer isn’t “more docs.” It’s not even “AI-generated docs.” It’s Atomic Context Documentation : smaller, sharper, verified context that stays near the code and helps both humans and AI work on the system safely. In my new article, I break down: Why traditional docs fail the “second reader” (AI) From context to results 👉 Full Article If you’ve ever watched AI confidently guess wrong about your codebase, this one’s for you.

Cursor's Developer Habits Report is one of the clearest signals yet that AI coding has crossed from individual productivity into software-delivery infrastructure. The headline numbers read as a story about speed: more code per week, larger PRs, deeper agent sessions, more changes committing without manual review. The deeper implication is governance -- whether teams can preserve architectural intent while generation, review, automation, and commit flows all accelerate at once. The velocity curve is now measured, not anecdotal. For two years the claim that AI coding is accelerating rested mostly on vibes and vendor decks. Cursor's data turns it into telemetry. And read as an operations document rather than a marketing one, that telemetry describes a structural shift: software delivery is getting harder to govern, not just faster to produce. This is not a critique of Cursor. The report is strong validation. Cursor proves the velocity curve with numbers most of the industry only gestured at. The point of this essay is what sits on the other side of that curve. What the Cursor Developer Habits Report Shows The inaugural Cursor Developer Habits Report (Spring 2026 edition), published by Cursor (Anysphere, Inc.), draws on Cursor usage data rather than survey responses. It captures the transformation across five themes -- developer acceleration, the economics of intelligence, the power user gap, the rise of context, and the shift to automation. The headline figures: 3.6K -> 8.6K lines added per developer per week -- the per-developer code volume rose from 3.6K (Jan 2025) to 8.6K (May 2026), with growth accelerating since the start of 2026. 125.86 -> 345.02 lines per PR at p75 -- lines added per pull request at the 75th percentile rose roughly 2.5x year over year (Jan 2025 to May 2026). Developers are taking on larger units of work in a single PR. 8% -> 13.8% mega PRs -- the share of PRs with at least 1,000 changed lines grew from 8% (Jan 2025) to 13.8% (May 2026). ~30% mor

Microsoft's Agentic Transformation Patterns Playbook is a useful signal because it does not treat AI agents as another productivity tool. It frames agentic AI as an enterprise operating-model shift: agents are moving from assisting humans to executing work across processes, systems, and teams. The implication for software teams is sharper than it looks -- coding agents are on the same trajectory, and architectural governance becomes part of the infrastructure stack the moment agents start executing. Microsoft's playbook describes six transformation patterns and emphasizes that each pattern requires different ownership, governance, and operating discipline. That is the move worth paying attention to. It reframes agentic AI from a model question into an enterprise operating-model question. That shift matters for software teams because coding agents are following the same path. They are moving from autocomplete to execution. Once agents edit files, open PRs, modify infrastructure, or coordinate multi-step changes, architectural governance becomes infrastructure. What is Microsoft's Agentic Transformation Playbook? Microsoft's playbook is a practical guide for choosing, scaling, and operating AI agents across the enterprise. Public summaries describe it as a 52-slide guide covering six transformation patterns, from employee productivity to core business processes and customer-facing agents. The throughline is that agents are not a single category -- they are a family of patterns with different ownership models, different risk surfaces, and different requirements for governance. That framing matters because it cuts against the dominant adoption narrative. Most enterprises are still treating AI as a per-team productivity story: this team gets Copilot, that team gets an internal assistant, another team is piloting an agent for support tickets. Microsoft is arguing that the pattern of deployment determines the operating discipline required, and that ad-hoc deployment does n

Google's Managed Agents announcement is one of the clearest signals yet that the AI industry is moving beyond stateless tool calling toward persistent execution environments and long-running agent systems. That shift expands what models can do. It also expands the governance surface -- from prompt and PR review into the runtime itself. We spent two years building brains in jars For most of the current AI cycle, the system around the model has been thin. Models could reason, propose commands, and orchestrate small tool calls. But they ran in short sessions, against narrow APIs, under human supervision, with ephemeral state. The model was a brain; the body was a few HTTP requests and a JSON tool schema. That assumption is ending. The frontier is not just better reasoning. It is a body for the brain. The brain finally has a body. Now it needs governance. The runtime layer for AI agents is arriving Google Managed Agents (and the parallel motion across the ecosystem -- OpenAI's containerized execution work, Claude Code's persistent sessions, MCP-based tool ecosystems, hosted agent harnesses) formalizes the runtime as a product: Sandboxed execution Persistent state across sessions Orchestration loops Infrastructure-native agents Agent-as-a-service lifecycle Long-running sessions Mid-session tool injection Managed runtime lifecycle This resembles the transition from scripts -> applications -> cloud platforms. Agents are no longer just calling tools. They are beginning to inhabit programmable environments . Why persistent agent systems change governance Once agents can continuously modify filesystems, maintain state across sessions, autonomously remediate, inject tools dynamically, operate against production systems, and coordinate across workflows, governance failures stop being one-off review misses. They compound over time . What that compounding looks like: Architectural drift -- small deviations accumulate across long-running sessions Policy propagation failures -- con