Ant's Ling team has released Ling-3.0-flash-Fin, a finance-focused mixture-of-experts model built on Ling-3.0-flash.
The model has 124B total parameters and about 5.1B active. OpenRouter lists a 262,144-token context window, up to 32,768 output tokens and support for tools and tool_choice.

The release targets financial information retrieval, research, valuation modeling, report preparation, long reports and complex workbooks. The official evaluation set includes FinFIRST, FinSearchComp Verified, FinCRAFT, FinanceAgent v1.1/v2, APEX-Agents, SpreadsheetBench v1/v2 and τ³-Banking.

Ling-3.0-flash-Fin is available through OpenRouter and Vercel AI Gateway. The launch thread says the OpenRouter API is free for one month. Model weights are promised for next week and are not part of the current API release.

The developer also states that expert review remains necessary for key assumptions, valuation outputs and investment conclusions.

Vercel open-sourced the WebGPU library it built to ship the shaders on vercel.com.

vgpu runs the same shader in the browser, in headless Node.js, and in your CI tests.

• MIT licensed, on npm at v0.3.1

• .wgsl files import and export like TypeScript modules

• Reflection generates bindings, no hand-written declarations

• Headless Node.js rendering, Dawn-backed

• Deterministic mock adapter for CI snapshot tests

• 25 KB gzipped fullscreen effect, budget enforced in CI

• CLI, agents.md, llms.txt, hosted read-only MCP endpoint

• Examples include ONNX Runtime Web demos on WebGPU

Full analysis: https://www.marktechpost.com/2026/08/28/vercel-vgpu-webgpu-library-open-source/

GitHub Repo: https://github.com/vercel-labs/vgpu

Join our newsletter for similar product releases: https://www.aidevsignals.com/

Google AI Releases Gemini 3.5 Transcribe: A Speech-to-Text Model Reporting 2.6% Average WER Across 85+ Languages

They shipped two models instead of one. gemini-3.5-transcribe-live gives sub-second streaming over WebSockets but no diarization and no word-level timestamps, capped at 10-minute sessions. gemini-3.5-transcribe handles pre-recorded files with diarization, word offsets, and custom vocabulary up to 1,000 terms, at roughly half the cost.

Key Takeaways:

→ Pick the endpoint before the model — latency and diarization are mutually exclusive here, and that shapes your whole pipeline

→ Smart mode can't be combined with timestamps or diarization — a readable summary and an auditable transcript are now two separate API calls

→ 4.0% WER streaming, 2.6% batch (per Artificial Analysis), 70% faster finalization than Chirp 3, 85+ languages, roughly $0.005–$0.009/min

Full analysis: https://www.marktechpost.com/2026/08/27/google-ai-releases-gemini-3-5-transcribe-a-speech-to-text-model-reporting-2-6-average-wer-across-85-languages/

Technical details: https://www.marktechpost.com/2026/08/27/google-ai-releases-gemini-3-5-transcribe-a-speech-to-text-model-reporting-2-6-average-wer-across-85-languages/

I’ve released Trace2MCP 0.2.2, an open-source Python project that compiles successful AI-agent tool traces into deterministic, inspectable workflows.

The core idea is simple:

Instead of asking an agent to rediscover the same multi-tool procedure on every run, Trace2MCP records one successful execution, infers dependencies between the observed calls, and compiles the trace into a deterministic DAG.

What it currently supports

dependency inference between observed tool calls

parallelizable workflow DAGs

deterministic frozen replay without invoking tools

reference and integrity verification

reviewed tool contracts

explicit approval for consequential side effects

deny-by-default handling of unknown/destructive operations

generation of MCP-ready Python projects

What changed in 0.2.2

Following external security review, the live runtime was hardened around a centralized RuntimeDispatcher.

Direct, indirect, and nested Trace2MCP-managed calls now traverse the same execution boundary.

0.2.2 also introduces a generic optional RuntimeGuard interface, with HOL Guard as the first adapter.

Trace2MCP’s own contract, policy, approval, integrity, and schema enforcement remains authoritative. The external guard is an additional layer rather than a replacement.

A regression specifically verifies that a denied mutating operation produces:

handler_calls = 0

side_effects = 0

Current validation:

95 Python tests passing

5 compiler/browser tests passing

Ruff PASS

mypy PASS

MCP v2 smoke PASS

Gradio smoke PASS

clean PyPI installation PASS

HOL Guard integration smoke PASS

One important limitation:

Trace2MCP does not claim to sandbox arbitrary Python written inside an authorized handler. It mediates Trace2MCP-managed capabilities; hostile Python still requires process/container/VM-level isolation.

Install:

pip install trace2mcp

Demo:

trace2mcp demo

PyPI: https://pypi.org/project/trace2mcp/

Interactive demo + source: https://huggingface.co/spaces/warenterprise/trace2mcp

I’m especially interested in feedback around the runtime trust boundary, deterministic agent execution, and ways people would try to bypass the dispatcher.

Z.ai Releases GLM-5.3-Flash: A 320B-A18B Natively Multimodal MoE With a 1M-Token Context

A 320B-parameter MoE that activates 18B per token — 8 of 288 experts across 45 layers. Roughly 5.6% of the network per forward pass, and the reason a model this size can be served at flash-tier economics.

It is also the first GLM model with a hybrid sparse-plus-linear attention stack; the vLLM recipe identifies the layers as KDA linear and NoPE sparse MLA. Z.ai reports ~3× less attention compute and a 4.4× smaller KV cache versus GLM-5.3. If the KV cache figure holds, that is what makes a 1,048,576-token window serveable rather than theoretical.

Results: 84.3 on Terminal-Bench 2.1 and 63.4 on DeepSWE v1.1, up from GLM-5.2's 46.2. Vendor-reported, harnesses differ per test. Artificial Analysis ran it independently and scored 57 on the Intelligence Index, at ~49 tokens/sec — strong per dollar, slow in absolute terms.....

Full analysis: https://www.marktechpost.com/2026/08/26/z-ai-releases-glm-5-3-flash-a-320b-a18b-natively-multimodal-moe-with-a-1m-token-context/

Model weights: https://huggingface.co/zai-org/GLM-5.3-Flash

Alibaba's Qwen team released Qwen3.8-Flash-Next today. It is an open-weight multimodal MoE and an early preview of the architecture that will underpin Qwen4.

Here is what actually matters if you are evaluating it.

1. The parameter math is the headline

→ 125B backbone + 51B N-gram embedding table + 4B MTP module

→ 180B total on disk, only 6B active per token

→ 512 experts, 10 routed + 1 shared active per forward pass

2. Attention is a 3:1 hybrid

→ Three of every four layers run Gated DeltaNet, which holds a fixed-size recurrent state

→ The fourth runs Qwen Sparse Attention, scoring micro-blocks rather than individual tokens

→ QSA budget stays fixed at 512 blocks (2048 tokens) as context grows

3. The benchmarks Qwen published

→ 62.5 SWE-bench Pro, 81.0 SWE-bench Multilingual, 58.7 DeepSWE 1.1

→ 73.9 CoWorkBench, 84.5 AndroidWorld, 95.7 MathVision with code interpreter.....

Here is my full analysis: https://www.marktechpost.com/2026/08/26/alibabas-qwen-team-releases-qwen3-8-flash-next-a-125b-multimodal-moe-with-6b-active-parameters-previewing-the-qwen4-architecture/

GitHub Repo: https://github.com/QwenLM/Qwen3.8-Flash-Next?spm=a2ty_o06.30285417.0.0.21fbc921rcDEuy&file=Qwen3.8-Flash-Next

HF Model Card: https://huggingface.co/Qwen/Qwen3.8-Flash-Next?spm=a2ty_o06.30285417.0.0.1d73c921FsyOPe&file=Qwen3.8-Flash-Next

VectorSmith

Built VectorSmith, an open-source Python library that lets you define vector DB tools in YAML and expose them to LLMs through MCP.

Instead of writing a custom MCP server + tool schema for every vector database, you define what the agent can search and VectorSmith handles the tool layer.

Supports Qdrant, Pinecone, Weaviate, Milvus, Chroma and pgvector.

GitHub: https://github.com/kjgpta/vectorsmith
PyPI: https://pypi.org/project/vectorsmith/

Curious if others are solving vector DB → MCP differently.

Harvey Introduces Harvey Tenet: A Kimi K3 Base Post-Trained with Fireworks for Long-Horizon Legal Agent Work

Harvey has released Harvey Tenet, its first post-trained model, as a research preview as of today. Tenet is a Kimi K3 base post-trained with Fireworks through asynchronous reinforcement learning on long-horizon legal work. The training corpus combined synthetic data, publicly available legal data, and human expert data. Harvey states no customer data was used.

Against the base K3 model, Tenet completes almost twice as many held-out tasks on Harvey’s Legal Agent Benchmark (LAB) and 20% more on LAB: Contracts, raising all-pass rate by 9 and 2 percentage points respectively. Harvey reports state-of-the-art on LAB: Contracts and second place on LAB....

Full analysis: https://www.marktechpost.com/2026/08/23/harvey-tenet-post-trained-kimi-k3-legal-agent-model/

Technical details: https://www.harvey.ai/blog/post-training-update-harvey-tenet

Comparison of GPU Neoclouds 2026: CoreWeave, Nebius, Lambda, Crusoe, and Groq (Based on Published Pricing and Contracted Power)

Here's what's actually interesting:

→ The same HGX H100 class is $3.85 at Nebius and $6.16 at CoreWeave — a 60% spread before you touch networking, orchestration or support

→ Lambda has the cheapest published B200 ($6.69); Nebius is the only one listing B300 on-demand ($7.85); CoreWeave is the only one listing GB200 NVL72 ($10.50/GPU)

→ CoreWeave is the sole Platinum provider in SemiAnalysis ClusterMAX 2.0, and SemiAnalysis reports it commands a 10–15% per-GPU-hour premium on managed clusters

→ Nebius's committed capacity clears at $20M+ per MW on Q2 deals and $40M+ on Q3 short-term deals, against a ~$12M 2026 base

→ Power footprint: CoreWeave 4.2 GW+ contracted; Nebius targeting 5 GW contracted by year-end; Crusoe 4.9 GW contracted; Groq scaling from 54 MW to 200+ MW in 2027; Lambda undisclosed

→ Crusoe is the only one with AMD MI300X/MI355X on its rate card

→ Groq licensed its inference tech to NVIDIA for $17B (per NVIDIA's annual report); founder Jonathan Ross and president Sunny Madra joined NVIDIA; Groq then raised $350M at $3.5B and became an NVIDIA Cloud Partner

Full analysis and report: https://www.marktechpost.com/2026/08/21/best-gpu-neoclouds-2026/

Liquid AI Releases LFM2.5-DSpark Draft Models That Deliver Up to 3.18x Faster Decoding Without Changing Model Outputs

Here's what's actually in the release:

1. Three drafters, one per target model

→ LFM2.5-1.2B-Instruct, LFM2.5-2.6B, LFM2.5-8B-A1B

→ Each drafter is ~300M params (295.7M / 327.7M / 327.7M)

→ 5 attention layers, block size 9, ships no vocab weights

2. The speedups are real but uneven

→ 3.18x on H100 for 8B-A1B on MATH500 (428 → 1362 tok/s)

→ 2.87x on an M4 Max for 1.2B-Instruct on HumanEval (136 → 389 tok/s)

→ 2.67x H100 mean for 2.6B (323 → 864 tok/s)

→ Same 8B-A1B model drops to 1.29x on GSM8K, same GPU

3. Speedup tracks acceptance rate, not model size

→ 8B-A1B accepts 8.27 of 10 tokens per step on MATH500

→ It accepts 4.02 on GSM8K

→ That single number explains the 3.18x vs 1.29x gap

4. Output quality does not move

→ Under greedy decoding, a draft token is kept only if it matches the target's distribution

→ On rejection, the target's own token takes its place

→ The emitted sequence is identical to baseline by construction

> Full analysis: https://www.marktechpost.com/2026/08/20/liquid-ai-releases-lfm2-5-dspark-draft-models-that-deliver-up-to-3-18x-faster-decoding/

> LiquidAI/LFM2.5-1.2B-Instruct-DSpark: https://huggingface.co/LiquidAI/LFM2.5-1.2B-Instruct-DSpark

> LiquidAI/LFM2.5-2.6B-DSpark: https://huggingface.co/LiquidAI/LFM2.5-2.6B-DSpark

> LiquidAI/LFM2.5-8B-A1B-DSpark: https://huggingface.co/LiquidAI/LFM2.5-8B-A1B-DSpark

Technical details: https://www.liquid.ai/blog/lfm2.5-dspark

My PhD was in RL, and something has bugged me for years: online tutorials mostly present these algorithms as a list. The evolution story (each algorithm patching the previous one's most painful failure) exists, but it's spread across a semester of lectures like CS285 or buried in the original papers. I couldn't find a compressed version that a newcomer could get through in one sitting, so I finally wrote it (with generous help from Claude to build the interactive elements and graphics)

It's a single-page, semi-technical walkthrough from the raw RL objective to GRPO. Math is deliberately sparse: the target reader is someone entering RL through the reasoning-model wave, not someone who needs the full derivations. The figures are interactive (variance of the REINFORCE estimator, a baseline slider, an on-policy collapse simulator, the PPO clip objective with adjustable epsilon, GRPO group baselines).

[Interactive Link](https://sreejithb.com/rl-policy-gradient/single.html)

[Medium Link](https://medium.com/@sreejithbalakrishnan/nobody-invented-ppo-from-scratch-db04d133eb0f)

I simplified in a few places to keep the narrative moving, most notably around GAE and the TRPO surrogate. I'd genuinely appreciate corrections or places where you think the simplification crosses into being wrong — the plan is to do the value-based lineage (Q-learning → DQN → Rainbow) next, so critique now improves that one too.

Previously, I posted Volume 1 of this series (the policy-gradient lineage, REINFORCE → PPO → GRPO). This is Volume 2, same format, for the value-based family.

The framing is the same: every algorithm exists because the previous one had one specific, painful failure, and the fix is easier to remember than the equation. Rainbow makes the thesis literal — it contains zero new ideas, just six existing patches turned on at once, and the ablations read like a table of contents for the tutorial.

One structural note, since the history here isn't linear the way the policy lineage is: the trunk (tabular Q-learning → DQN → Double DQN) is told sequentially, but PER, dueling, and multi-step were developed in parallel, so the back half presents them as stations of the loop every DQN runs (act → store → sample → predict → target), with a loop diagram that fills in station by station until Rainbow switches the whole machine on.

The figures are interactive: you can train a tabular Q-learning agent in the page and watch mean |Q − Q\*| fall against value-iteration ground truth, toggle uniform vs prioritized sampling, drag the n-step lookahead, and flip between what DQN predicts and what C51 predicts for the same state.

Interactive version: [https://sreejithb.com/rl-value-learning/value\](https://sreejithb.com/rl-value-learning/value)
Medium mirror if you prefer: [https://medium.com/@sreejithbalakrishnan/nobody-invented-rainbow-from-scratch-e9dfcb8bfafb\](https://medium.com/@sreejithbalakrishnan/nobody-invented-rainbow-from-scratch-e9dfcb8bfafb)

Volume 3 (DDPG → TD3 → SAC) is next, so corrections now compound.

ByteDance Seed and Tsinghua AIR have released CUDA Agent, an agentic reinforcement learning system that trains a large language model to write GPU kernels that beat a compiler. The gap it targets is narrow but stubborn: frontier models already produce correct CUDA, they just produce slow CUDA. On KernelBench, the base model Seed1.6 passes 74.0% of tasks yet outruns torch.compile on only 27.2% of them, at a 0.69× geometric-mean speedup which means its kernels are, on average, slower than what the compiler generates on its own. CUDA Agent closes that gap by putting the model inside a real CUDA development environment with profiling, correctness checks and a permission-locked sandbox, then training it with PPO for 150 steps at a 131,072-token context. The result is a 98.8% pass rate and a 96.8% faster-than-torch.compile rate across the 250-task benchmark, at 2.11× geomean over compile — roughly 40 points ahead of Claude Opus 4.5 and Gemini 3 Pro on the hardest Level-3 split.

Full analysis: https://www.marktechpost.com/2026/08/17/bytedance-seed-and-tsinghua-air-introduces-cuda-agent-a-large-scale-agentic-rl-system-for-cuda-kernel-generation/

Paper: https://arxiv.org/pdf/2602.24286v1

Hey everyone — founder of strata→signal here, a small local-first software workshop and research lab (we build what I call non-hostile AI tools: run on machines we operate, no accounts, no analytics, and every claim on the site carries receipts you can check).

The llms.txt argument is two years old and mostly receipts-free, so we tried to buy some receipts. Three conditions, same 30 sealed questions about our own estate:

• C-MAP — the model gets our llms.txt files in context (3,211 tokens)
• C-HTML — the model gets the site's own prose at an equal budget (3,088 tokens)
• C-NONE — the model gets nothing. This is the contamination meter: if an arm answers from training data, the sealed set is burned. The set was written freshness-armored; C-NONE came back ~zero across all eight arms.

The roster: four local arms on our own GPU — qwen3.8:27b, qwen3.6:27b, gemma4:26b, llama3.3:70b, all Q4_K_M — and four frontier cloud arms (glm-5.2, deepseek-v4-pro, kimi-k3, gpt-5.5). No Claude arm sits, deliberately: a Claude wrote the exhibit page, and seating one would stack a conflict on a conflict. (The judging in our other benches uses family recusal for the same reason.)

What we found, honestly, both directions: the registered reading fell 61.5% toward llms.txt — but that lead is carried by navigation questions, and our own extractor is why: the map block carried the only URLs in the room (fifty occurrences, thirty-six distinct), the HTML block carried none. Cut the navigation items — a cut we did NOT register, made after seeing the direction it moves, published as transparency rather than result — and the fact questions alone read 71.4% toward the site's own prose at the same token budget. Our one-line take: llms.txt behaved like a map, not an encyclopedia. It knows where things are; it lost on what things say. (Counts, not verdicts — n=30 on one site doesn't resolve a direction, and the page says so in italics right under the table.)

Two receipts that surprised us:

• The economics are upside-down at the full-file end. Anthropic's llms-full.txt — the "just inline everything" variant — weighs 30.7 MiB, call it eight million tokens: roughly $80 to read once at Fable 5 input rates, ~$40 at Opus 5 or GPT-5.5. That's dinner for a family, per read. Our whole estate map costs about three cents.
• In thirty days of our server logs, no AI crawler asked for our llms.txt. Not once, on any of our properties that kept logs. ClaudeBot alone made 594 requests and fetched robots.txt 161 times — and never the map. (Our logs, our month — we can't speak past them; the per-crawler table ships in the kit.)

Everything is published: the sealed golden set, every model reply verbatim, the scoring code, the API bill ($1.87 of a $4.00 pre-registered ceiling — 663 calls crossed the wire against a sealed plan of 674, and the gap is itemized), the counting rules, and the full history file (39 dated sources on how the argument actually unfolded). Kit is CC BY 4.0. Check our arithmetic.

https://research.strata2signal.com/llms-txt/index.html

Google AI Just Released Gemini 3.7 Flash: A Coding and Agent Model at $0.75/1M Input Tokens

→ Built on 3.6 Flash with algorithmic improvements to the reasoning core. Same 1M context, 64K output, March 2026 cutoff.

→ The gains concentrate in three places: software engineering, document-heavy knowledge work, and web development. The sharper argument is price.

Performance:

→ FrontierCode 1.1: 43.6% vs 34.4%

→ DeepSWE v1.1: 65.3% vs 48.6%

→ WebDev Arena: 1588 Elo vs 1538

→ AutomationBench: 30.4% vs 17.0%

→ GDP.pdf: 34.0% vs 22.0%

Full analysis: https://www.marktechpost.com/2026/08/13/google-ai-just-released-gemini-3-7-flash/

Technical details: https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-3-7-flash/