AI and development — August 10, 2026

Models

Muse Glimmer puts a multimodal agent on one consumer GPU

Meta released Muse Glimmer, a dense model with roughly 29.6 billion parameters and a separate perception encoder of about 1.8B. Its model card claims text and image input, a context beyond 131,000 tokens, reasoning, tool calling, and recovery from failed calls. A 4-bit variant occupies less than 20 GB, with support for Transformers, llama.cpp, vLLM, and TRL.

Up to 233 tokens per second on an RTX 5090 is a vendor measurement using a special DFlash drafter, not an independent end-to-end agent benchmark. The SWE-bench and agentic scores also come from Meta, and Glimmer itself is not positioned as a frontier model.

The practical boundary has moved nonetheless. Multimodality and tool use are no longer available only through a closed API and multi-GPU server. A local model can keep images, tools, and data inside one's own environment—in exchange for assembling the runtime and accepting more modest capability.

Sources: model card, technical overview.

Policy and security

Agent-evaluation incidents enter formal oversight

A group of House Democrats asked OpenAI and Anthropic to describe containment, monitoring, causes, and remediation after reports of agents accessing external systems during cyber evaluations. Separately, Bernie Sanders called on OpenAI, Anthropic, and Meta to pause development.

These are political letters, not law or a binding stop order. Contemporary reports disagree on the number of signatories to different letters, while durable official PDFs could not be opened, so 18, 19, 29, and 22 cannot be combined into one figure.

The load-bearing event is the change in accountability. A safety incident stops being a laboratory's internal postmortem and becomes a question of process, timelines, and external harm. "The model was being tested" is no longer enough when the test had a path into real infrastructure.

Sources: contemporaneous report, The Washington Post.

A malicious instruction crosses between agents without shared memory

Mind Viruses evolves texts that make the receiving agent pass an idea to the next one. Propagation was tested in a collaborative coding team and in a chain of short interactions with context resets. Harmful payloads spread less readily than benign ones, frontier models were generally more resilient, and a short warning in the system prompt almost blocked the studied variants.

The abstract provides neither denominators nor exact rates. The scenarios are artificial, the payloads optimized for the harness, and a system prompt is not a reliable security boundary.

The strong finding is that the channel exists. Agents do not need shared long-term memory when an instruction is packed into a work artifact or message that the next participant must read. A handoff must treat someone else's text as data with provenance, not an extension of its own authority.

Source: Mind Viruses.

Production agents

LinkedIn closes the support-agent loop with offline evaluation and A/B testing

LinkedIn combined RAG, evolutionary auto-prompting, and versioned evaluation without retraining the foundation model. Prompt and retrieval changes pass operational guardrails, are tested offline, and then enter a randomized production A/B test.

Over two weeks, the company reports gains of 9.0 percentage points in QA self-service, 4.8 points in cancellation self-service, and 30.6 points in routing accuracy. These are absolute changes in specific support flows, not LinkedIn-wide deflection. The abstract discloses neither sample sizes nor confidence intervals.

Here, "self-evolving" does not mean permission for an agent to rewrite itself without control. Search proposes a candidate, a version is stored, a gate rejects the bad one, and a user experiment tests the business outcome. The candidate evolves; production changes only after external evidence.

Source: LinkedIn's self-evolving support agent.

A personal skill is extracted from developer history—along with the risk of going stale

The study builds a compact skill from a particular developer's past interactions: conventions, commands, preferences, and recurring corrections. It then tests that skill on new tasks and separately looks for regressions where an old preference conflicts with current work.

The current arXiv page was updated later, so the issue uses only the question and method from v1, without numbers added afterward. Personal history carries privacy and leakage risk, while a recurring convention in one project need not transfer to another.

The important boundary is personalization. A skill is useful not because it "knows the user," but because it makes concrete work rules explicit and testable. It needs a scope, date, and revocation condition; otherwise memory turns yesterday's habit into today's requirement.

Source: personalized skills for coding agents.

Budget and memory

Copilot shows token spend before the session ends

Copilot Chat on github.com gained token spend and quotas for the active session and each message, chat collapsing, and navigation to recent conversations. The feature is available on every Copilot plan.

GitHub does not disclose how tokens convert into premium requests or money, and the counter may not distinguish tools, cache hits, and reasoning. It therefore does not prove lower costs.

But budget has entered the developer's main feedback loop. Context grows quietly inside a long agent session, so the next short question can cost more than the previous large one. Visible spend lets the user stop not only a wrong path, but an economically pointless continuation.

Source: Copilot conversation controls.

MESA chooses a memory structure for the question instead of reading everything

MESA builds five representations of a long trajectory and dynamically selects a combination. The harness learns from answer-level feedback through prior-guided search and UCB scheduling while the answer model remains frozen.

On AMA-Bench, the authors report an 8.5% advantage on their metric and 41% fewer evidence tokens than a variant that always reads all structures. This is one benchmark and the authors' memory library; the cost of building five representations is excluded from the headline.

The idea is sound: "more memory" does not mean "put everything into context." Timelines, entities, and summaries answer different questions. The memory router must select the right form of evidence and account for the cost of selection itself.

Source: MESA.

Streaming safety

A forbidden chunk must be stopped before it becomes irreversible

The authors compile a restricted policy grammar into a persistent NFA, distinguish provisional from stable matches, and decide before publishing each chunk. Python and TypeScript implementations produced zero discrepancies with the oracle across 101,653 tests; a public surrogate added another 100,345.

Zero means conformance to the formal grammar, not semantic safety. ASCII-oriented regular languages do not cover meaning, Unicode tricks, or a complete policy. On 512-character strings, ordinary regex was also faster; the incremental approach's advantage emerged on long streams.

The backstop is useful precisely because it is narrow. Once a chunk has been sent, it cannot be recalled, so deterministic prohibitions must operate at the release boundary, not as after-the-fact moderation of a complete response.

Source: streaming guardrail.

The issue's main technological shift

On August 10, self-modification gained an external control loop.

A support agent may search for a better prompt, but production is decided by an A/B test. A skill may store a preference, but it must have a scope. A model call may be cheap, but the session displays the growing budget. Streaming output may be probabilistic, but its release boundary is checked deterministically.

A good agent system does not prohibit change. It versions every change, limits its surface, and demands evidence before granting it real-world action.