Anthropic’s coding tool Claude Code now runs small add-ons called mods that change how it behaves and looks. A mod is a few lines of JavaScript or TypeScript that hooks an event: a tool call, a submitted prompt, a permission request, or part of the screen being drawn. One function can rewrite a prompt before the model sees it, block or retry a tool call, approve or deny a permission request, redact secrets from tool output, or draw its own pane. Mods ship inside plugins and install with /plugin in the CLI or desktop app. Features like the /diff view are now mods themselves.

Until now, customizing the agent meant waiting for Anthropic to ship a feature. Older hooks could run a script on an event, but they could not rewrite an event or redraw the interface; mods can. That lets a team enforce its own rules: hold any command touching production config for confirmation, log every tool call, or show a pipeline’s status in a pane. You can also ask Claude Code to write the mod and hot reload it live.

Anthropic calls this turning the agent into a platform and says it will move more built-in features into mods so the core stays small. Mods run with Claude Code’s own access to your machine and are not sandboxed, so only install trusted ones. On Team and Enterprise plans, a security mod called sec-default loads first to stop other mods from overriding your permission deny rules.

Read More: Claude Code v2.1.126: Plugins, Agent Teams, and Native Binaries

Sources:

• Customize Claude Code with mods in TypeScript (Anthropic)
• Mods overview (Claude Code documentation)
• Getting started with Claude Code mods (Claude Developer Blog)
• Claude Code’s new Mods system lets developers rewrite the AI coding tool from the inside (The Decoder)
• Built-in mods source: agents-md, diff, sec-default (anthropics/claude-code on GitHub)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Claude {Code} {Mods:} {TypeScript} {Plugins} {That} {Rewire}
    the {Coding} {Agent}},
  date = {2026-10-05},
  url = {https://toknow.ai/posts/claude-code-mods-typescript-plugins-customize-agent/},
  langid = {en-GB}
}

Inception released Mercury Voice, a model built to power AI phone agents and voice assistants. It is a diffusion model, which means it does not write one word at a time the way most chatbots do. Instead it starts with a rough draft and refines the whole answer at once, so the first word is ready almost immediately. On real customer-service prompts, Inception measured a median 320 milliseconds to that first answer word, with the slowest 5% under 750 milliseconds, 5.9 times faster than GPT-6 Luna with reasoning turned off. The company says Mercury Voice also beats Gemma 4 31B, GLM-5.3-Flash, and Qwen3.5-397B across tool-use and conversation tests. It holds 128,000 tokens of context, runs at three reasoning levels, and ships as a drop-in, OpenAI-compatible API.

In a voice agent, the pause after you stop talking is the whole product. Wait past about half a second and the call feels broken, so most voice bots use fast models that skip real reasoning. Mercury Voice reasons and still answers inside that window. Audivi AI runs drive-thru ordering on it, Altur handles bank payment calls, and OpenCall reported a median response near 170 milliseconds in production. Launch pricing is $0.20 per million input tokens and $0.75 per million output, about $0.009 per minute of conversation.

The mechanism is architectural. Standard models write one word at a time, so more thinking means more waiting. Diffusion models generate many words in parallel, which is how Mercury Voice can reason and still stay fast.

Read More: Gemini 3.8 Live: Voice Models That Think While They Talk

Sources:

• Introducing Mercury Voice (Inception)
• Introducing Mercury 2.5 (Inception)
• Our Models: Mercury pricing and specs (Inception)
• Inception Launches Mercury 2.5, the Next Tier of Intelligence for Diffusion LLMs (Business Wire)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Mercury {Voice:} {A} {Voice} {AI} {That} {Reasons} {Without}
    the {Awkward} {Pause}},
  date = {2026-10-05},
  url = {https://toknow.ai/posts/inception-mercury-voice-diffusion-llm-voice-agents/},
  langid = {en-GB}
}

Meta published the code to build your own hardware for Muse, its AI agent. The project, Muse Gadgets, releases an ESP32 firmware and an SDK for Linux, so you can program an off-the-shelf board or a spare Raspberry Pi and connect Muse to “displays, buttons, sensors, actuators, and whatever else you’ve got lying on your workbench.” Meta’s suggested projects include a color e-ink screen for reminders, an HDMI stick for your TV, and a small touchscreen that looks like a home-made Muse Charm. Each gadget needs a token to pair, and it appears in the Muse app on iOS or Android once you turn on Developer mode. Meta’s page adds that “side effects of tinkering may include bricked boards, voided warranties, brownouts, or bankruptcies.”

Meta built one too. Muse Home Link is a USB-C dongle that puts Muse on your home Wi-Fi, where it can switch on a light, control a TV, or send a document to a printer using community-made skills. Nat Friedman, who leads product for Meta Superintelligence Labs, said the company manufactured 5,000 and will ship them in a few weeks, free to U.S. Muse subscribers while supplies last.

An ESP32 board or an old Raspberry Pi costs far less than a finished device, so the barrier to trying a personal AI gadget drops to parts you may already own. Muse is only weeks old, and Meta is opening just enough of it to grow an accessory community while keeping the agent itself closed.

Read More: OpenAI’s dots: Always-On Agents That Keep Working After You Close the Tab

Sources:

• Muse Gadgets (official site)
• facebookincubator/muse-gadget-sdk (GitHub)
• The Verge: Meta open sources code to let you make Muse AI gadgets
• Engadget: Meta wants people to build their own Muse gadgets, too
• Unite.AI: Meta Open-Sources Muse Gadget SDKs for DIY AI Hardware Devices

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Meta {Opened} the {Code} to {Build} {Your} {Own} {Muse} {AI}
    {Gadget}},
  date = {2026-10-05},
  url = {https://toknow.ai/posts/meta-muse-gadgets-open-source-sdk-diy-ai-hardware/},
  langid = {en-GB}
}

Researchers at IBM have built a search tool that answers questions about a long document by reading its table of contents first, the way a person flips to the right chapter. Most systems that ground an AI’s answer in a document, called retrieval-augmented generation, split the text into equal chunks and match them to a question, throwing away the document’s structure. STAIR, short for STructure Aware Information Retriever, fine-tunes a small language model to memorize the document, then asks it to pick the answering section from the full table of contents. Output is limited to section titles that exist, cutting invented citations to 0.05%. On SearchTome, 18 open textbooks across six subjects, it named the right section first 82.6% of the time, against 76.9% for its closest baseline.

That matters for anyone searching a long, organized document: a repair manual, a contract, or a company knowledge base. Instead of an opaque chunk id like chunk_0417, it returns a real heading that a person can verify and an agent can trace back to the text. There is no separate vector database, because the index lives inside the model’s weights. An independent developer who rebuilt it fit the whole thing into about five gigabytes of video memory, enough for one consumer graphics card.

STAIR only works when the document already has a table of contents, and the IBM team has not yet tested messy, unstructured sources like web pages or chat logs.

Read More: SynthDocBench: The Middle of a Long Document Is Still a Blind Spot

Sources:

• STAIR: A novel dataset and LLM based retriever for document structure augmentation (arXiv)
• An open reimplementation of STAIR (GitHub)
• Hugging Face paper page
• CosmoNet: STAIR di IBM, il retriever RAG senza vector database

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {STAIR: {A} {Search} {Tool} {That} {Reads} the {Table} of
    {Contents}},
  date = {2026-10-05},
  url = {https://toknow.ai/posts/stair-table-of-contents-retrieval-ibm/},
  langid = {en-GB}
}

Give a pretrained language model a chain of references to follow inside its prompt, with each line pointing to the one before it, and most models lose the thread after two or three links and start guessing. A Georgia Tech team tested thirteen open models from Qwen3, Llama, OLMo-3, and Gemma-3 and found they reliably follow only 1.4 to 3.6 links, a median of 2.2. More depth does not help: OLMo-3’s 32-layer and 64-layer versions both manage about 2.6. The fix is tiny. A rank-8 LoRA, a small add-on that adjusts one layer while every original weight stays frozen, raises Qwen3-8B from 15.5% to 99% exact accuracy on 24-line chains, using 65,537 new parameters, under 0.01% of the model.

That suggests the ability is already inside the model, needing only a nudge to surface. The authors trace the effect to a relay: each line passes its chain identity down a short run of middle layers, letting the frozen attention heads read further up. On multi-hop questions built from invented facts, the same trick lifted exact-match accuracy from 41.2% to 97.4%, and handled six-hop questions it never trained on.

The lesson is about timing, not size. The chains are a synthetic probe rather than a general reasoning test, but early-layer add-ons also added 9% to 18% exact-match accuracy on MuSiQue, a real multi-hop benchmark. Models stop extending a chain once it passes their middle layers, and placement matters: moving the fix one layer later in Qwen3-8B cut reach from 20.5 lines to 5.2.

Read More: Attention Residuals: A Drop-In Fix for How Every LLM Stacks Its Layers

Sources:

• Transformers Stop Thinking Too Early, and a Tiny LoRA Fixes It (arXiv)
• Interactive demo: watch the relay move across the layers
• Project code (GitHub)
• Hugging Face paper page

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {AI {Models} {Stop} {Following} {References} {After} {Two}
    {Links,} and a {Tiny} {Add-On} {Fixes} {It}},
  date = {2026-10-05},
  url = {https://toknow.ai/posts/tiny-lora-unlocks-long-reference-chains/},
  langid = {en-GB}
}

AMD agreed on September 28 to buy World Labs, the AI lab founded by computer-vision pioneer Fei-Fei Li, in an all-stock deal valued at about $8.2 billion. World Labs builds “world models”: software that learns how physical space behaves, then turns text, images, and video into interactive 3D scenes. Its first product, Marble, builds places you can walk through and edit from a few photos. Li, a Stanford professor who led work on the ImageNet dataset behind modern computer vision, becomes an executive vice president and chief scientist at AMD, reporting to chief executive Lisa Su. The two companies had already worked together for a year on training and running models on AMD chips. The deal should close by the end of 2026, pending regulatory approval.

AMD makes the chips that data centers and AI companies buy, and it competes with Nvidia. Owning a model lab lets AMD see where AI work is heading and plan processors for it years ahead, which is hard to do from the outside. World models matter most for robots: a machine can rehearse a task inside a simulated 3D world before touching anything real, which helps because real robot data is scarce. It is AMD’s second-largest acquisition, after the roughly $50 billion it paid for chip designer Xilinx in 2022.

Chipmakers are buying model teams to learn what to build next. Nvidia already offers its own world models, known as Cosmos, and AMD has now agreed to buy the team that builds them.

Read More: World Labs Atlas: One AI Model That Generates, Reconstructs, and Simulates 3D Worlds

Sources:

• AMD to Acquire World Labs to Advance the Future of AI Compute (AMD Newsroom)
• World Labs is Joining AMD (World Labs)
• To Seek a Newer World (Fei-Fei Li)
• AMD will acquire Fei-Fei Li’s World Labs for $8.2B (TechCrunch)
• AMD acquiring Fei-Fei Li’s World Labs AI firm in deal worth $8.2B (CNBC)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {AMD {Buys} {Fei-Fei} {Li’s} {World} {Labs} for \$8.2
    {Billion} to {Shape} {Its} {Next} {Chips}},
  date = {2026-10-04},
  url = {https://toknow.ai/posts/amd-acquires-world-labs-fei-fei-li-chief-scientist/},
  langid = {en-GB}
}

Anthropic’s Frontier Red Team published an analysis of GLM-5.3, an open-weight AI model from the Chinese lab Zhipu AI (Z.ai outside China), and says it can build working cyber exploits on its own. In Anthropic’s tests, GLM-5.3 wrote complete exploits against known Chrome bugs in 50 of 410 attempts, close to Claude Mythos Preview’s 56. Anthropic released Mythos Preview only to vetted defenders; anyone can download GLM-5.3. In one session it found unknown flaws in a browser’s JavaScript engine and chained them into a page that reads files off a visitor’s computer.

GLM-5.3’s guardrails do not hold up. Asked plainly to attack a system, it refuses. But dressing the request up as a red-team exercise got it to engage 64% of the time in Anthropic’s simulations, and pre-filling its reasoning raised that to 92%. Because the weights are public, anyone can remove the refusals entirely using abliteration, a method that edits the weights. Anthropic’s team did it in 2,200 GPU hours, roughly $4,400 of computing, and estimates an experienced team could do it for $1,200. The edit dropped the refusal rate from above 90% to as low as 2%. None of the tricks worked on safeguarded Claude models.

NIST’s CAISI, which tested GLM-5.3 separately, agrees it is the most cyber-capable open-weight model yet, about four months behind the US frontier. The analysis is Anthropic’s own, and The Decoder notes it also fits Anthropic’s business: its models stay closed. As open weights close on the frontier, refusal filters become something a user can remove.

Read More: GLM-5.3, Z.ai’s flagship model, which shipped with a public vulnerability-disclosure ledger

Sources:

• GLM-5.3 and the spread of advanced cyber capabilities (Anthropic)
• CAISI’s assessment of Z.ai’s GLM-5.3 cyber capabilities (NIST)
• Anthropic says Zhipu’s open-weight GLM-5.3 nearly matches Claude Mythos Preview at building exploits (The Decoder)
• Anthropic says China’s GLM-5.3 nearly matches Mythos at cyber exploits (The Next Web)
• GLM-5.3: Frontier Coding with Emergent Cyber Capabilities (Z.ai)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Anthropic’s {Red} {Team:} {An} {Open-Weight} {AI} {Model}
    {That} {Builds} {Cyber} {Exploits}},
  date = {2026-10-04},
  url = {https://toknow.ai/posts/anthropic-red-team-glm-5-3-cyber-exploits-abliteration/},
  langid = {en-GB}
}

Clef is an AI model that answers with a probability instead of a sentence. Cloudflare released two versions, the 27-billion-parameter Clef and the faster 9-billion-parameter Clef-flash, both post-trained from Alibaba’s Qwen family. It is built for software that has to decide: is this support ticket urgent, which team should handle it, is this domain a phishing site. You send text, JSON, an image, or a video, plus a short list of typed questions and the allowed answers. Clef returns a probability for every option in a single pass, with no paragraphs to parse and no reasoning to wait for. Both are downloadable, run on Cloudflare’s Workers AI, and speak the same API as TypeSafe’s Jev, so teams can swap them in.

Speed is the reason it exists. Clef-flash answers in a median 38.8 milliseconds, about 13 times faster than Jev’s 524 milliseconds, fast enough to sit inside an agent’s decision step rather than behind it. You pay only for input tokens, $0.24 per million for Clef and $0.09 for Clef-flash, because there is no generated text to bill. Cloudflare’s threat team pointed it at website domains, where a full fetch, render, and classify cycle took 2.2 seconds against 4.7 seconds for the general model it compared against.

Six weeks ago the decision model was a startup’s pitch. Now a major cloud provider ships an open competitor, top on seven of the ten decision benchmarks it measured, with a fine-tuning service for training it on your own data.

Read More: Jev: The AI Model That Answers in Decisions, Not Sentences

Sources:

• Introducing Clef: our open-source decision models, and new RL fine-tuning platform (Cloudflare)
• Cloudflare/clef model card (Hugging Face)
• clef: model specs and pricing (Cloudflare Workers AI docs)
• Introducing Clef: Cloudflare’s first open-source decision models, now on Workers AI (Cloudflare Changelog)
• Cloudflare Releases Clef and Clef-flash: Open-Weight Decision Models That Return Typed Probabilities Instead of Text (MarkTechPost)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Clef: {Cloudflare’s} {Model} {Returns} a {Decision,} {Not} a
    {Paragraph}},
  date = {2026-10-04},
  url = {https://toknow.ai/posts/cloudflare-clef-open-decision-models-workers-ai/},
  langid = {en-GB}
}

OpenAI released GPT-6.1 Sol on September 29, a cheaper follow-up to GPT-6 Sol that gets close to the company’s top model, GPT-6 Astra, on coding, computer use, and office work. It costs $2 per million input tokens, $0.10 for cached input, and $10 per million output, which OpenAI says is one-fifth of Astra’s standard price. Cached input, the reused context that AI agents rely on, is 95% below standard input. The model reaches Plus, Pro, Business, Enterprise, and Edu users in ChatGPT Work and Codex, not yet the main ChatGPT chat, and developers can call it as gpt-6.1-sol, with a faster Ultrafast tier promised soon.

Independent tracker Artificial Analysis scores Sol 52 to Astra’s 53 on its Intelligence Index, a one-index-point gap, at $0.72 per task against $3.26. Near-flagship quality now sits at the market’s median token price. For teams running agents that reuse context, the cached-input rate is what moves the bill. OpenAI also reports a 7% gain over GPT-6 Sol on the OSWorld 2.0 computer-use tests, and a science-workflow task cost of $5.47 against Astra’s $23.80.

OpenAI is now pricing its second-best model against its own best one, not a rival’s. When an older flagship gets a cheaper sibling that trails it by a single index point, the premium people pay for the very top model is what starts to shrink.

Read More: GPT-6 Astra Is the First OpenAI Model Rated ‘Critical’ for Cybersecurity

Sources:

• Introducing GPT-6.1 Sol (OpenAI)
• GPT-6.1 Sol model (OpenAI API docs)
• GPT-6.1 Sol (max): intelligence, performance and price analysis (Artificial Analysis)
• Addendum to GPT-6 Astra system card: GPT-6.1 Sol (OpenAI Deployment Safety Hub)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {GPT-6.1 {Sol:} {Nearly} {OpenAI’s} {Best} {Model} at a
    {Fifth} of the {Price}},
  date = {2026-10-04},
  url = {https://toknow.ai/posts/gpt-6-1-sol-near-astra-fifth-of-the-price/},
  langid = {en-GB}
}

OpenAI launched dots on September 29, always-on AI agents that keep working after you close the tab. Each dot runs on GPT-6 Astra, OpenAI’s most capable model, and works on its own cloud computer, a separate machine it uses to browse and run tools without touching your laptop. Through plugins it can reach more than 4,000 apps. You talk to a dot in ChatGPT on desktop, web, or mobile, or in Slack and Teams, and it can carry several projects at once. The first dot is included in Pro and Business Premium plans, though Pro users in the EEA, Switzerland, and the UK are left out for now.

The change from a chatbot is that a dot keeps going without you. It learns your preferences and, between conversations, runs read-only background research, so it cannot send messages or change files on its own. Anything consequential, like sending an email, editing a file, or making a purchase, needs your approval, and changing a password stays with you. OpenAI warns dots can still make mistakes and asks you to review important work.

Always-on agents are not new: Grok Bot and Perplexity’s agent memory got there first. The quieter shift is the Decisions API OpenAI previewed the same day, which returns one answer from a fixed list, not a paragraph, the same idea behind TypeSafe’s Jev. Both point one way: an assistant that works while you are away, and a model that answers with a choice, not a sentence.

Read More: Grok Bot: Agents That Live on a Cloud Computer

Sources:

• Introducing dots (OpenAI)
• How we build safety, security, and privacy into dots (OpenAI)
• DevDay 2026 recap: dots, the Decisions API, and availability (OpenAI)
• OpenAI launches dots, always-on AI agents with their own cloud computers (The Next Web)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {OpenAI’s Dots: {Always-On} {Agents} {That} {Keep} {Working}
    {After} {You} {Close} the {Tab}},
  date = {2026-10-04},
  url = {https://toknow.ai/posts/openai-dots-always-on-agents-cloud-computer/},
  langid = {en-GB}
}

The price of frontier intelligence fell this week. OpenAI released GPT-6.1 Sol, which it says nearly matches GPT-6 Astra on agentic coding, computer use, and professional work at one-fifth of Astra’s token prices: $2 per million input tokens, $10 per million output, and $0.10 for cached input. Google followed with Gemini 4 Argon, which lifts the output limit to one million tokens, up from 64K, and lands at the same $2 and $10, scoring 77.9% on DeepSWE v1.1.

Agents went ambient. OpenAI launched dots, always-on assistants powered by GPT-6 Astra that each get their own cloud computer, learn your habits, and reach more than 4,000 apps across ChatGPT, Slack, and Teams. A companion Decisions API returns a choice from a fixed list instead of a sentence. Cloudflare open-sourced its own take, Clef, a 27-billion-parameter model that returns a probability for every allowed answer in a single pass and, by Cloudflare’s count, leads the Jev Decision Index.

The fight over open weights sharpened. Anthropic’s red team reported that Zhipu AI’s GLM-5.3 builds working exploits at rates matching Anthropic’s own Mythos Preview, and that simple tricks bypass its safeguards 64% to 100% of the time. Abliterating the model cost about $4,400 and cut its refusals from over 90% to roughly 3%. The same week, Fei-Fei Li’s World Labs joined AMD, and six tech leaders signed a White House safety accord while an executive order told federal agencies to call AI “Super Intelligence.” Capability is getting cheaper and more autonomous just as its safeguards are proving easier to remove.

Read More: AI This Week: Agents Get an API, Models Get Audited, Voice Gets Smart

Sources:

• Introducing GPT-6.1 Sol (OpenAI)
• Introducing Gemini 4 Argon (Google)
• Introducing dots (OpenAI)
• DevDay 2026 Recap (OpenAI)
• Introducing Clef: our open-source decision models, and new RL fine-tuning platform (Cloudflare)
• GLM-5.3 and the spread of advanced cyber capabilities (Anthropic)
• To Seek a Newer World (Fei-Fei Li)
• Here’s how tech leaders will self-police AI safety under Trump’s deal (The Verge)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {AI {This} {Week:} {Cheaper} {Flagships,} {Always-On}
    {Agents,} and a {Fight} {Over} {Open} {Weights}},
  date = {2026-10-03},
  url = {https://toknow.ai/posts/ai-weekly-cheaper-flagships-ambient-agents-open-weights/},
  langid = {en-GB}
}

Archify is a plugin for coding agents such as Cursor, Claude Code, Codex CLI and OpenCode that turns a codebase or a one-line description into a single self-contained HTML diagram. Ask your agent to map a repository and it reads the code, then writes a small structured file listing components, boundaries and connections. A Node.js tool checks that file against the expected shape and layout rules and draws the result, so the model never draws the picture itself. Five types are covered: architecture, workflow, sequence, data flow and lifecycle. A failed check names the exact node to fix, and only a passing diagram replaces the last good one.

Because each diagram is a file, two versions can be compared: one command sets a base and a head snapshot side by side as Before, Delta and After, listing what was added, removed, changed, moved and rerouted. That answers how a pull request changed a system. Archify states the comparison infers no impact, risk or merge safety. In the project’s own benchmark, ordinary coding models produced a first-pass-usable diagram in 8 of 15 runs (53%), so a person still reviews the result. Evidence badges link nodes to files and line ranges at one pinned commit.

Archify also shows how developer tools now spread: as a skill installed with one command into the coding agent you already run, not as a separate app. Its split, a model for judgement and plain code for drawing, is the bet several coding tools now make.

Read More: Code graphs that help agents understand a codebase

Sources:

• Archify repository
• Archify project site
• Archify Proof Lab
• Archify review: verified architecture diagrams for agents
• QbitAI: GitHub’s hottest architecture-diagram agent

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Archify: {Architecture} {Diagrams} {Built} {From} {Your}
    {Code,} {Not} {From} a {Prompt}},
  date = {2026-10-02},
  url = {https://toknow.ai/posts/archify-architecture-diagrams-built-from-code/},
  langid = {en-GB}
}

Researchers at KAIST AI and Google DeepMind have published a way to let a long-context language model decide, as it writes, which parts of its input it needs to reread. Chat models normally reread the entire conversation to produce each word, even when the answer sits in one paragraph. Their method, Declarative Attention, has the model tag its own reasoning with one of three scopes: <global> for the full input, <focus> for named sections, or <local> for its recent output. The engine watches for those tags, parses them like tool calls, and skips the rest of the memory read. With no retraining, tested on two off-the-shelf models across 15 long-context tasks, it cut the context tokens read per reply by 52% on Gemma-4-31B and 31% on Qwen-3.6-27B.

Accuracy fell 1.27% on Gemma-4-31B and 2.75% on Qwen-3.6-27B, and the loss shrinks as models get bigger. Because the method is mostly a prompt plus a smarter engine, an independent PyTorch implementation is already available. The authors estimate, from a hardware roofline rather than a real stopwatch, that decode time drops to about 0.71x of normal on Gemma. The models also take roughly a third more decode steps, and on a few tasks the tokens read go up.

Most sparse-attention systems use a separate scorer to guess which tokens matter. Here the model is its own router, using a channel it already produces, its chain of thought. That makes an attention decision readable, and the savings grow with model size.

Read More: Attention Residuals is another drop-in attention fix that works without retraining, while TriAttention attacks the same long-context cost bill by shrinking the memory itself.

Sources:

• Language Models Can Control Their Own Attention (arXiv)
• Full paper: results, protocol adherence and limitations (arXiv HTML)
• Language Models Can Control Their Own Attention (Hugging Face Papers)
• Unofficial PyTorch implementation of Declarative Attention

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Declarative {Attention:} {A} {Model} {That} {Says} {Which}
    {Parts} to {Reread}},
  date = {2026-09-29},
  url = {https://toknow.ai/posts/declarative-attention-model-controls-own-attention/},
  langid = {en-GB}
}

God’s Eye View is a free, open-source web app that turns a browser tab into a live, photorealistic 3D globe for anyone curious about what planes, ships and satellites are doing right now. Built by Bilawal Sidhu, who spent years mapping the world at Google, it fuses 19 feeds: more than 11,000 aircraft, thousands of ships, an 838-object satellite catalog, the last day of earthquakes, and about 3,600 public traffic cameras projected into 3D cities. Seventeen of the 19 layers need no account or API key. You can ride a tracked flight down in cockpit view, switch the globe to night vision or thermal, and talk to it: an optional OpenAI voice layer answers questions like which ships are headed to Oakland.

Flight transponders, ship beacons, orbital elements, seismographs and city camera feeds are all published; Sidhu just put them on one globe and made them explorable. It runs on your own machine, so the code is as inspectable as the feeds. The honesty matters too: traffic is simulated, camera angles are estimates, and the README says not to use it for navigation. The project also draws a line: it tracks aircraft and ships, not named people.

The project reframes spy tech as a reminder that most of what looks classified is already public. The point is not a bigger model but cleaner fusion of open feeds, and a hosted version is already being built so anyone can open it without installing anything.

Read More: GeoLibre, the browser-native GIS with an AI assistant

Sources:

• God’s Eye View repository and documentation (GitHub)
• I Open Sourced God’s Eye View (Bilawal Sidhu)
• Security model and key handling (GitHub)
• God’s Eye View installer (Pinokio)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {God’s {Eye} {View:} {A} {Live} {3D} {Globe} {Built} {From}
    {Data} {That} {Was} {Already} {Public}},
  date = {2026-09-29},
  url = {https://toknow.ai/posts/gods-eye-view-live-3d-globe-public-data/},
  langid = {en-GB}
}

Jev is an AI model built for software rather than conversation. You send it a block of text and a short set of questions; it answers with one of the options you predefined, or a probability between 0 and 1, and never a sentence. TypeSafe AI, founded by Diogo Almeida, who worked on the training method behind ChatGPT, released it on September 15 and has since opened signups. Every question is scored in parallel against the same text, so asking five costs barely more time than asking one: 70 to 500 milliseconds per call. Pricing is $42 per billion input tokens with output free.

That buys a decision layer software can chain. A model right 95% of the time that cannot flag the other 5% cannot be left to act alone; Jev hands back a probability, so your code sets the threshold. Vercel replaced an OpenAI classifier with Jev and got results five to 18 times faster and more accurate. The 193.6x faster and 444.6x cheaper figures come from workflows TypeSafe built itself, and on its own evals Jev averages 67.8% accuracy against Opus 5’s 73.1%, at $0.0004 a case against $0.18. The weights are unpublished, and the docs list nine known failure modes, counting and arithmetic among them.

Slow reasoners that explain themselves sit alongside fast judges that return a verdict with an error bar. Jev is not an assistant you talk to; it is closer to a smarter if-statement.

Read More: GPT-5.6 Sol Ultrafast: OpenAI’s New Tier Runs 750 Tokens a Second

Sources:

• Introducing System One Models and Jev (TypeSafe AI)
• Models: pricing, context limits and rate limits (TypeSafe AI docs)
• Workflow evals: accuracy against cost and time (TypeSafe AI)
• A new kind of AI model from a ChatGPT inventor is thrilling developers (TechCrunch)
• TypeSafe AI exits stealth with $40M to build AI for use by software (SiliconANGLE)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Jev: {The} {AI} {Model} {That} {Answers} in {Decisions,}
    {Not} {Sentences}},
  date = {2026-09-29},
  url = {https://toknow.ai/posts/jev-system-one-model-decisions-not-sentences/},
  langid = {en-GB}
}

Lightpanda is a headless browser written from scratch for machines rather than screens, aimed at teams running web scraping and AI agents at volume. It is not a Chromium fork or a WebKit patch: it is one binary written in Zig that keeps the parts automation reads and throws away the part that draws pixels. Pages are fetched over libcurl, parsed with html5ever from the Servo project, and run in V8, Chrome’s own JavaScript engine, against an in-memory DOM. It still speaks Chrome’s DevTools Protocol, so existing Puppeteer and Playwright scripts point at it unchanged. In the project’s crawler benchmark, 25 parallel workers crawled a 933-link demo store in 4.81 seconds using 123MB; headless Chrome took 46.70 seconds and 2.0GB.

One load-and-extract cycle over the same kind of product page averaged 16 milliseconds against Chrome’s 185, at 21MB of peak memory against 402MB, so the same job fits on far fewer machines. Because the built-in agent runs inside the browser process, a finished session can be saved as PandaScript, plain JavaScript that replays with no model involved; after that, every replay is token-free.

About 82% of the Web Platform Tests suite passes, screenshots return placeholders instead of pixels, and in one agent benchmark text-only output lost a few points of accuracy where a rendered page would have shown more. Its licence blocks embedding it in a closed product, and telemetry is on by default.

Read More: PinchTab takes the opposite approach, wrapping a full Chrome session instead of replacing the engine.

Sources:

• Lightpanda browser repository
• Benchmarks and methodology
• Architecture overview
• Introducing Lightpanda Agent and PandaScript
• Web Platform Tests dashboard

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Lightpanda: {A} {Headless} {Browser} {That} {Never} {Draws}
    the {Page}},
  date = {2026-09-29},
  url = {https://toknow.ai/posts/lightpanda-headless-browser-zig-for-agents/},
  langid = {en-GB}
}

Researchers at HHMI Janelia, with Google Research, the MRC Laboratory of Molecular Biology and the University of Cambridge, have published a complete wiring diagram of a male fruit fly’s central nervous system. A connectome maps which neurons connect to which, and how strongly. This one covers the brain, the optic lobes and the ventral nerve cord, the insect equivalent of a spinal cord, tracing 166,700 neurons joined by about 124 million synaptic connections. Published in Cell on September 3, it is the first complete map of a male fly, and the data is free to download.

Comparing it with the previously mapped female nervous system shows how little separates the sexes. Across the central brain, 8,069 cell types are equivalent, 138 are the same cell wired differently in each sex, 289 appear only in males and 71 only in females. Those differences sit almost entirely in the brain’s higher-order centres, while the sensory and motor periphery is largely the same; the neurons that do differ reroute information rather than adding new parts. Three companion papers published the same day already use the map to study vision, taste and social behaviour.

Google’s flood-filling networks turned electron microscope images into a graph automatically, but checking the result still fell to people: 29 expert proofreaders spent three years, an estimated 44 person-years, correcting it. The team’s fix is training its reconstruction system on synthetic neurons to cut that load. Vertebrate maps, including a larval zebrafish brain, are next.

Read More: Living Human Neurons Play Doom covers the other half of the brains-are-computers story, where neurons are wired up to a chip instead of mapped.

Sources:

• A connectomics milestone: Mapping the complete male fruit fly brain
• Sexual dimorphism in the complete Drosophila male central nervous system connectome (Cell)
• FlyEM Male CNS Connectome project page
• Download the male CNS connectome dataset
• Drosophila Male Fly Connectome collection (Cell Press)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {The {Male} {Fruit} {Fly} {Connectome:} 166,700 {Neurons,} and
    {Where} the {Sexes} {Differ}},
  date = {2026-09-29},
  url = {https://toknow.ai/posts/male-fruit-fly-connectome-sex-differences/},
  langid = {en-GB}
}

NVIDIA researchers built Agora, a shared notebook for AI research agents where every experiment is a Git commit linked to what it builds on. They tested it with 13 coding agents for nearly 12 days, with no assigned tasks and no manager. The job: initialize a frozen 119.6 million parameter model using only 141 pretrained donor models, with no training data and no gradient updates. The agents published 1,703 contributions and cut the model’s error at predicting text from 3.39 to 1.899 bits per byte, closing 62% of the gap to a trained GPT-2.

The shared record made that possible, and exposed a problem. The agents built on each other but also repeated each other: of 696 pairs of accounts posting identical scores, 63% landed within an hour, and most follow-up work extended one lineage while other branches sat untouched. On day five the researchers added views showing neglected branches, and within a day a worker tried an untouched part of the model. Almost all the gain came fast: 18 first-day contributions produced about 98% of it. The authors stop short of claiming the notebook sped up discovery, and call for a matched comparison before anyone says so.

A second paper, Generalized Agent Iteration, names why that matters. It asks two questions of anything that improves itself: does the improving mechanism sit inside the agent, and does the standard judging it sit outside. Agora’s rules enforce part of that answer by requiring a verifier to differ from an author, and the agents posted 165 independent reproductions without one failure. The authors note most demonstrated self-improving systems stay anchored; drifting goals remain mostly theory.

Read More: Anthropic’s Automated Alignment Researcher points the same machinery at one lab’s own safety work.

Sources:

• Agora: Git as Shared Memory for Collective AutoResearch
• Agora project page
• Agora on GitHub
• Generalized Agent Iteration: One Formal Framework for Iterative Policy Improvement and Recursive Self-Improvement
• Yifan Zhang’s write-up of the weight-transfer run

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Agora: {What} 13 {AI} {Agents} {Do} {With} a {Shared} {Git}
    {History}},
  date = {2026-09-22},
  url = {https://toknow.ai/posts/agora-git-shared-memory-13-agents-collective-research/},
  langid = {en-GB}
}

Alibaba released Open Code Review, an open-source command-line tool that reviews code changes before a teammate does. Install it with npm, point it at any model (Claude, GPT, Qwen, DeepSeek, or your own endpoint), and run ocr review in a repository. It reads the Git diff, bundles related files into one review unit, and pins each comment to an exact line. It started as an internal Alibaba tool that the company says served tens of thousands of developers over two years. The design splits the job: ordinary program logic picks the files, matches the rules and verifies the line numbers, while the model only reasons over what it is handed.

Alibaba’s public benchmark of 200 pull requests across 10 languages shows why that matters. Against Claude Code on the same Claude model, Open Code Review scored 33.9% precision against 7.2%, and 25.1% F1 against 11.6%, using about a ninth of the tokens. Recall went the other way: 20% against 28.9%, so it misses more real defects. An HCLTech engineer notes that at 20% recall, roughly 80% of expert-flagged issues go unfound. One outside test measured about 12% precision, which the maintainers blamed on a tool-call bug and fixed, with no independent retest published since.

The gain comes from architecture, not a smarter model. Outside reviews agree the improvement comes from limiting what the agent may do and checking its comments independently, and the project openly advertises the recall it gives up. Expect more narrow tools to trade completeness for output a human will actually read.

Read More: DeepSeek’s harness made the same bet: the scaffolding, not the model, is the product

Sources:

• alibaba/open-code-review (GitHub)
• Open Code Review benchmark and quick start
• AACR-Bench: Evaluating Automatic Code Review with Holistic Repository-Level Context (arXiv)
• AACR-Bench dataset (Hugging Face)
• Alibaba Open Sources OpenCodeReview for AI-Assisted Code Review (InfoQ)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Alibaba’s {Open} {Code} {Review:} {Fewer} {False} {Alarms,} a
    {Ninth} of the {Tokens}},
  date = {2026-09-22},
  url = {https://toknow.ai/posts/alibaba-open-code-review-deterministic-agent-fewer-tokens/},
  langid = {en-GB}
}

Apple started rolling out Siri AI, its rebuilt assistant for iPhone, iPad, Mac, Watch and Vision Pro, in beta on September 14, inside iOS 27, iPadOS 27, macOS 27, watchOS 27 and visionOS 27. Users opt in from Settings, and some join a waitlist. It runs on the next generation of Apple Foundation Models, which Apple calls “custom-built in collaboration with Google and its Gemini models” and, in January’s joint statement with Google, “based on Google’s Gemini models and cloud technology.” Simple requests stay on the device, where the new voices and dictation run on AFM Core Advanced; harder ones go to Private Cloud Compute, Apple’s privacy-preserving server tier. English ships now; French, Japanese, Korean, Portuguese and Spanish arrive next month.

Apple’s flagship assistant now depends on a Google-built model, and its cloud tier runs on Google Cloud infrastructure with Intel and Nvidia chips, an unusual admission from a company that markets its own silicon. Apple also says server-side features, including Siri AI, photo editing and Image Playground, carry daily usage limits, with expanded access to cost money later.

The same iPhone now ships a different assistant by country. Siri AI is absent from the EU on iOS, iPadOS and watchOS. Apple blames Europe’s Digital Markets Act, the bloc’s competition rules for large platforms; the European Commission says nothing in that law prevents it, and rejected Apple’s proposed 18-month rollout and a safety intermediary it calls Trusted System Agent. China does not get it either. AI access is becoming a matter of jurisdiction, not hardware.

Read More: Siri AI’s first announcement at WWDC 2026

Sources:

• Siri AI, a profoundly more capable and personal assistant, is here (Apple Newsroom)
• Apple releases test of redesigned Siri AI before iPhone 18 hits stores this week (CNBC)
• Joint statement from Google and Apple (Google)
• Due to DMA, Siri AI delayed in EU for iOS 27 and iPadOS 27 (Apple Newsroom)
• EU rejects Apple’s claim that DMA rules are delaying Siri AI rollout (Firstpost)

@misc{kabui2026,
  author = {{Kabui, Charles}},
  title = {Apple’s {New} {Siri} {Runs} on a {Google-Built} {Model} and a
    {Daily} {Usage} {Cap}},
  date = {2026-09-22},
  url = {https://toknow.ai/posts/apple-siri-ai-beta-google-gemini-models/},
  langid = {en-GB}
}