Security-Specialized AI Goes Compact

Security-Specialized AI Goes Compact

Cisco dropped Antares this week: a family of compact language models -- 350M, 1B, and 3B parameters -- purpose-built for agentic vulnerability localization. Based on IBM Granite checkpoints and trained through supervised fine-tuning on cybersecurity reasoning data followed by reinforcement learning from verifiable rewards, Antares-3B approaches GPT-5.5 on VLoc Bench while being orders of magnitude smaller. The numbers are striking: a full 500-task evaluation sweep completes in approximately 15 minutes on a single H100, at an amortized cost of less than $0.002 per task. Given only a CWE category description and terminal access, Antares autonomously searches a codebase, inspects files, follows call chains, and submits vulnerable paths -- end-to-end, no static-analysis front end, no frozen frontier API wrapper. Cisco publicly released the 350M and 1B variants on HuggingFace (more: https://cisco-foundation-ai.github.io/antares/technical-report.pdf) (more: https://huggingface.co/fdtn-ai/antares-1b) (more: https://www.linkedin.com/posts/mitkox_cisco-just-dropped-antares-a-tiny-security-focused-share-7485391273172873218-M166).

The training pipeline is worth understanding. Antares uses a two-stage approach: supervised fine-tuning on a security and deep research corpus plus terminal trajectories teaches the model how to navigate repositories, then GRPO reinforcement learning over vulnerable repos optimizes complete multi-turn trajectories using verifiable file-level localization rewards. The RL stage induces a search-verify-refine policy -- the model learns to hypothesize, check, and revise rather than grepping blindly. Task-specific training dominates raw parameter scale: Antares-3B outperforms open-weight models 200x larger because it has learned the search strategy, not just the vocabulary.

Google simultaneously shipped Gemini 3.5 Flash Cyber, a fine-tuned variant of Flash built specifically for finding and fixing cybersecurity vulnerabilities. Within CodeMender -- Google's multi-agent security orchestrator -- Flash Cyber reaches competitive frontier performance on the CyberGym benchmark. Unlike Antares, Flash Cyber is exclusively available to governments and trusted partners through a limited-access pilot, which says something about how seriously Google takes the dual-use problem. Meanwhile, Gemini 3.6 Flash landed as a broader efficiency upgrade: 17% fewer output tokens than 3.5 Flash, DeepSWE scores jumping from 37% to 49%, and pricing at $1.50/$7.50 per million tokens. Flash-Lite pushes throughput to 350 output tokens per second (more: https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-3-6-flash-3-5-flash-lite-3-5-flash-cyber).

Underpinning the urgency: the linux-cve-announce mailing list published over 400 CVEs in a single 24-hour window. The coordination gap between kernel maintainers and downstream distributions remains the structural weakness it has always been -- a vulnerability goes uncoordinated unless the reporter chooses to engage linux-distros. AI-accelerated scanning is almost certainly changing the disclosure cadence, and the volume is outpacing human triage capacity (more: https://lore.kernel.org/linux-cve-announce/).

Formal Verification's AI Moment

Formal verification is crossing a threshold: it is no longer just something AI does to math. It is becoming something AI does to itself. TraceFix, presented at the ACM Conference on AI and Agentic Systems, introduces a verification-first pipeline for multi-agent coordination using TLA+ and PlusCal. An orchestration agent synthesizes a protocol topology from a task description, generates model-checkable coordination logic, and iteratively repairs it using TLC counterexample traces until verification succeeds. On 48 tasks spanning 16 scenario families, TraceFix achieves 100% final TLC verification -- 62.5% pass on the first attempt, and none require more than four repair iterations. State spaces span six orders of magnitude yet verification completes in under 60 seconds for every task. In runtime comparison across 3,456 runs, topology-monitored execution hits 89.4% average task completion and degrades at roughly half the rate of prompt-only baselines when model capability drops (more: https://arxiv.org/abs/2605.07935v1).

This matters because multi-agent coordination is a distributed systems problem, and no amount of model intelligence can escape the impossibility arguments. FLP tells us we cannot guarantee both safety and liveness; Byzantine generals set hard bounds on fault tolerance. TraceFix does not try to solve these impossibility results -- it exploits a fundamental asymmetry: generating a correct concurrent protocol is hard, but checking one is mechanical.

On the infrastructure side, franken_lean is a ground-up Rust reimplementation of the entire Lean 4 toolchain -- parser, macro engine, elaborator, trusted kernel, VM, build system, and language server. The kernel is constrained to 12 KLOC with forbid(unsafe_code), produces proof certificates, and ships agent-native MCP tools over O(1) proof-state snapshots. Mathlib's tactics run unmodified on franken_lean's own VM. Given how central Lean 4 has become to the AI-for-math research program, a clean reimplementation that eliminates the C++ substrate, GMP dependency, and per-worker 60-second import tax is architecturally significant (more: https://github.com/Dicklesworthstone/franken_lean). For those wanting to understand the verification landscape, HashCloak published a solid introductory tutorial on formal verification with Lean (more: https://hashcloak.com/blog/tutorial-introduction-to-formal-verification-with-lean-(part-1)).

And then there is the headline result: Claude Fable 5, guided by Anthropic mathematician Akhil Mathew, appears to have disproved an 87-year-old conjecture that Smale listed as problem #16 on his 18 problems for the 21st century -- the same list that includes P vs NP and the Riemann Hypothesis. The computation is simply checkable, and the r/math community has confirmed credentials and verified the approach. This is a counterexample, not a complex proof, which makes it more credible: a single verifiable case that kills the conjecture. The consensus framing is right -- human-AI collaboration, not AI supremacy -- but it is the highest weight class any LLM has reached in pure mathematics (more: https://old.reddit.com/r/ClaudeAI/comments/1v1b4i8/fable_may_have_disproved_a_100_year_old_conjecture/).

The Agentic Coding Arms Race

Poolside released Laguna S 2.1: a 118B-parameter MoE model with 8B activated per token, trained start-to-launch in under nine weeks. It scores 70.2% on Terminal-Bench 2.1 with thinking enabled (60.4% without), supports a 1M-token context window, and independently re-derived a proof to Erdos problem #397 in a 68-minute session using Perl for number theory -- a structurally different construction from the known six-index family. Poolside's thesis is explicit: raw intelligence is one axis, but model disposition -- persistence, verification, willingness to backtrack -- is a second axis that matters immensely. They are publishing full trajectories for every trial in every benchmark, which is how evaluation should work (more: https://poolside.ai/blog/introducing-laguna-s-2-1).

The Fable Method takes a different angle on the same problem. Rather than scaling model size, it distills the workflow Claude Fable 5 used during its final days into a set of skills any model can follow: classify the ask, define done, gather evidence in parallel, commit to one recommendation, change the smallest correct thing, verify by observation. Across 15 eval rounds and 260+ agent runs with blind LLM judges, the method's value concentrates at traps -- authority conflicts, false completion claims, weak executors -- not everywhere. Haiku with the method catches 4/4 spec-vs-test conflicts that bare Haiku misses entirely. The lift is inversely proportional to model tier, which is the repo's thesis (more: https://github.com/Sahir619/fable-method).

Laguna S 2.1 also built a working HTML/CSS rendering engine from an empty folder in one 50-minute session of 181 steps with no human intervention, then proved it rendered correctly by running headless Chromium and comparing screenshots numerically. In a separate run, it made Poolside's own agent harness 5.2% faster with 70% lower memory allocation. These are not benchmark scores -- they are observed engineering sessions where the model diagnosed O(n^2) string concatenation, replaced it with buffers, and verified the fix with race detection.

OpenRouter's Auto Router beta closes the loop on routing: classify each request by task type, then route to the best model for that task based on aggregate performance data. IBM Research showed just days ago that routing is harder than it looks -- caching dynamics alone can flip which model wins on cost -- but the direction is inevitable. The question is no longer which model to use but which model for which subtask at which cost (more: https://openrouter.ai/openrouter/auto-beta).

Open Weights and the Inference Frontier

Ben Werdmuller frames the strategic picture cleanly: American AI is locked down and proprietary; China releases openly. The result is that China turns a US-created compute disadvantage into a distribution advantage, commoditizing the layer where American companies make money. Martin Casado at a16z notes that 80% of startups are already using Chinese models. The gap is closing -- Stanford HAI documented the China-US capability frontier as "effectively closed" -- and the US response of tighter export controls may be accelerating the very outcome it seeks to prevent (more: https://werd.io/american-ai-is-locked-down-and-proprietary-its-losing/).

The practical question from the LocalLLaMA community cuts through the geopolitics: how do we actually benefit from 2T+ models when even extreme hardware setups cannot run them at usable speed? The best answer is architectural trickle-down. Dynamic 1-bit and 2-bit quantization is cramming models in the high hundreds of billions onto unified-memory setups while retaining roughly 80% of base intelligence. A year ago that reasoning level was locked behind cloud APIs. The mega-models push boundaries; the community distills and optimizes that intelligence down to hardware we actually own (more: https://old.reddit.com/r/LocalLLaMA/comments/1v0py81/how_do_we_benefits_from_2_t_models/).

The concrete proof of concept: one developer served a fleet of Qwen3.5 122B sessions on a single 96GB Mac Studio. Across a 20-minute test with three concurrent sessions, 789,351 prompt tokens were offered and only 48,996 recomputed on the GPU. The other 93.8% came from an on-disk KV cache -- a 16x cut in prefill compute, three chats running on about one GPU's worth of work. This is a 122B dense model, not a small MoE, running concurrent sessions on a $4K desktop. The local inference frontier just moved (more: https://old.reddit.com/r/LocalLLaMA/comments/1uzpk4g/serving_a_fleet_of_qwen35_122b_sessions_on_a/).

Agent Workspaces and Developer Tooling

Block (formerly Square) open-sourced Buzz, a self-hostable workspace where humans and AI agents share the same rooms. Built on Nostr -- every message, reaction, workflow step, review approval, and git event is a signed event in one log. Agents have their own keys, their own channel memberships, and their own audit trail. The differentiator from the growing pile of AI workspace tools: agents can open repos, send patches, review code, run workflows, edit canvases, orchestrate other agents, and drop into voice huddles. Same affordances as a human teammate, same audit trail, different keypair. The identity model is unified -- person or process, same protocol, same search index (more: https://github.com/block/buzz).

RuvNet Brain takes a different approach: instead of building a new workspace, it indexes 69 repositories of existing open-source AI tooling (149,721 source chunks) into a downloadable knowledge bundle for Claude Code. The core insight is that Claude's training data lags the frontier of its own plugin ecosystem -- tools built ahead of the model's knowledge cutoff get quietly talked down to older patterns. Brain bridges that gap by making real source code available at inference time. The honest self-audit is notable: 88 instances of teaching "prove it works before calling it done" across 19 projects that cannot see each other, knowledge gates that can interrupt held 8/8 while prose rules held 0/6 (more: https://isovision.ai/ruvnet-brain).

Deepfakes, Surveillance, and the Accountability Gap

A Filipino domestic worker lost a year's savings -- 100,000 Philippine pesos, about $1,625 -- to a deepfake romance scam impersonating Dubai's Crown Prince Sheikh Hamdan. The scammer used real-time AI face-swapping on video calls where lip sync matched the words, though the voice did not match the real prince. AFP traced the operation to criminal syndicates in Nigeria who have embraced AI-generated imagery and deepfake video to make impersonation scams more convincing. Multiple Facebook groups pretending to represent the prince drew thousands of followers, with manipulated but highly realistic images -- the prince kneeling with a ring, holding a red rose. The $25 million Hong Kong Arup incident from 2024 showed deepfake video calls could fool corporate finance. Now the same technology targets individuals whose year's savings is $1,625 (more: https://old.reddit.com/r/AINewsMinute/comments/1uy6tya/woman_loses_savings_to_aipowered_romance_scam/).

The economics of deepfake fraud have inverted. Creating a convincing real-time face swap no longer requires a specialized lab -- consumer-grade AI tools can produce lip-synced video calls that fool people who have no reason to suspect deception. The FBI's Internet Crime Complaint Center has documented over a billion dollars in losses from victims aged 60 and older in 2026, with romance scams as the fastest-growing category.

On the surveillance side, Flock Safety's camera network has crossed 110,000 units and is growing by hundreds per day. The stated purpose is license plate recognition, but the limiting factor is software, not hardware -- these cameras see everything. The expansion trajectory now includes school buses, garbage trucks, and package delivery vehicles, which would crawl every street in every neighborhood multiple times weekly, tagging plates in private driveways. Paired with Alpha Vision, an AI system that connects to existing camera infrastructure and processes pre-crime by profiling people based on walking speed, loitering duration, clothing, gender, and ethnicity, the combination amounts to mass behavioral surveillance with no warrant requirement. A government using a private company to surveil citizens, then claiming the data is private when citizens request it under public records laws, is not a hypothetical -- it is current policy in Washington state (more: https://www.youtube.com/watch?v=hcUeZFJ9ojk) (more: https://www.youtube.com/watch?v=B5_yZ5EJ01M).

Silicon, Simulation, and the Shape of What Comes Next

Intel confirmed that notebooks containing silicon partly patterned on a $380 million High-NA EUV scanner are heading to customers now. These are Panther Lake processors -- Core Ultra Series 3 laptop parts built on Intel 18A -- with a subset of layers dual-qualified on both the new 0.55 NA optics and the mature 0.33 NA tools. The High-NA scanner raises numerical aperture from 0.33 to 0.55, sharpening the smallest single-exposure feature by roughly a third and replacing multi-patterning steps with single exposures. ASML is building twelve to fifteen systems a year and has guided to roughly twenty by 2028. The production EXE:5200B runs about 175 wafers an hour at 0.7 nm overlay, a 60% lift over the R&D model. Intel is running the tool on a node designed without it, so that by the time 14A arrives and High-NA becomes a necessity, recipes and teams have already learned. This is the reverse of Intel's EUV foot-dragging on 10nm, and TSMC is the one waiting this time (more: https://morethanmoore.substack.com/p/intel-starts-shipping-high-na-euv).

NVIDIA and collaborators published a comprehensive survey of the simulation landscape for physical AI, documenting the shift from visualization tools to core model-development infrastructure. MuJoCo, Isaac Sim, Isaac Lab 3.0, and the new Newton physics engine (developed jointly by NVIDIA, Google DeepMind, and Disney Research under Linux Foundation governance) represent a stack where simulation generates perception datasets, trains RL policies, collects demonstrations, and stress-tests against adversarial scenarios. Isaac Lab 3.0 decoupled from Omniverse, becoming a multi-backend framework that can run headless Newton physics for high-throughput or full Isaac Sim for photorealistic rendering. An unusual amount of this core infrastructure is open-source and GPU-accessible, which lowers the barrier to entry for anyone building in embodied AI (more: https://huggingface.co/blog/nvidia/state-of-simulation-for-physical-ai).

The AI-2040 scenario analysis -- a 47,000-word document from former insiders -- lays out a specific timeline: a US-China agreement by 2029, scaling to top-human-expert AI by 2035, and a $10 million annual universal dividend per person by 2040. The document explicitly frames itself as a floor: if whoever controls superintelligence offers less than this, you are being shortchanged. The analysis acknowledges that the CEOs of OpenAI, Anthropic, and Google DeepMind understand they may end up controlling the world's only army of superintelligences and are proceeding anyway, "perhaps because they think they are the lesser evil." Whether you find this reassuring or terrifying depends on how much faith you place in the benevolence of people who have already decided the question for you (more: https://lifearchitect.substack.com/p/the-memo-special-edition-ai-2040-com).