AI 资讯 · 每日前沿动态

Schema-Adaptive Action-Conditioned JEPA for Cross-Machine CNC Transfer under Partial Sensor Overlap

arXiv cs.LGarXiv:2609.16071v1 Announce Type: new Abstract: Cross-machine deployment of industrial world models requires transfer across changes in dynamics, sensing interfaces, sampling regimes, and control units. We study a schema-adaptive action-conditioned Joint-Embedding Predictive Architecture (SAAC-JEPA) for CNC dynamics, where the source machine has 17 canonical sensor channels and the target shares only 10. Evaluation uses group-disjoint source splits, source-only normalization, held-out self-supervised validation, unit audits, and a sealed target test after model locking. Across five seeds, JEPA pretraining gives no clean-source forecasting gain: scratch and pretrained-body models obtain $\mathrm{RMSE}=0.811\pm0.022$ and $0.813\pm0.022$. A source-only search over 20 candidates selects a schema-consistent action-conditioned JEPA after seven-seed stability checks. On the confirmatory target pass, the locked model reaches zero-shot $\mathrm{RMSE}=0.546$, $R^2=0.012$, and $\mathrm{NLL}=0.52$, outperforming persistence but not RevIN-equipped PatchTST and iTransformer baselines ($0.503$ and $0.498$). A pre-declared paired ablation shows that RevIN in the same architecture improves RMSE to $0.495\pm0.004$ over three seeds, but degrades target calibration ($\mathrm{NLL}=20.6$) on stationary context windows. A pre-lock adaptation sweep further reduces RMSE to $0.520$ with limited target support. These results show that source-domain forecasting accuracy alone is insufficient to assess industrial predictive representations, and that cross-machine adaptation under partial sensor overlap is a distinct evaluation axis.

2026-09-16 04:00:00 · Transformer,扩散模型,强化学习,预训练,世界模型,向量数据库,长上下文,招聘HR,论文

VideoMM: Adaptive Macro-Micro Inference for Efficient Video MLLMs

arXiv cs.CLarXiv:2609.16722v1 Announce Type: cross Abstract: Scaling Multimodal Large Language Models (MLLMs) to long-form video understanding is bottlenecked by the explosion of visual tokens, which saturates context windows and incurs prohibitive costs. Current solutions predominantly rely on auxiliary models for token reduction but face a fundamental dilemma: lightweight encoder-driven approaches often overlook critical semantic information, whereas heavyweight MLLM-driven reduction negates the efficiency gains. {In this work, we identify a more fundamental inefficiency underlying this dilemma: while fine-grained visual details are essential for detailed understanding, they are largely redundant for the preliminary task of selecting semantically relevant regions. } Motivated by this, we introduce \textbf{VideoMM}, which marks a paradigm shift from model-centric downsizing to adaptive perceptual granularity. Specifically, our framework {decouples selection from reasoning} by executing semantic filtering on a cost-effective \textit{Macro Proxy} (derived from downscaled frames), and projecting the selected regions onto high-fidelity \textit{Micro Tokens} for detailed understanding only when necessary. Extensive evaluations show that VideoMM significantly outperforms existing solutions. It achieves a 6.13$\times$ speedup and a 7.4\% accuracy gain over full-context baselines on LongVideoBench, and further accelerates inference by 2.73$\times$ over current leading methods, establishing a highly scalable paradigm for long-video understanding. Our code is available at: https://github.com/adfh917k/VideoMM.

2026-09-16 04:00:00 · 大模型,开源,多模态,推理思考,长上下文,论文

Where Should a Document Live: Context, Representations, or Parameters?

arXiv cs.CLarXiv:2609.17346v1 Announce Type: new Abstract: To answer questions outside of their pre-training data, large language models (LLMs) need access to new information, which can be presented in the context window as documents, encoded into the model's parameters, or injected as latent representations. However, each of these methods comes with different efficiency, cost, and performance trade-offs, with no single winner. We present a controlled comparison of representation-based (KV-cache based) and parametric (fine-tuning-based) adaptation methods on five knowledge-intensive benchmarks. We show that in the oracle setting, Cartridges (KV) are the most accurate injection method at nearly every storage budget, outperforming parametric methods by 10 points. Compaction (KV) matches Cartridges only at low compression rates, lagging behind the parametric methods by 10 points at rates higher than $50\times$. In the more realistic multi-document retrieval scenario, Cartridges are the only method that matches in-context learning (ICL), leading the parametric methods by 29 points and Compaction by 15 points. Nonetheless, Cartridges are also the only method, besides full fine-tuning and large MLP adapters, that suffers from catastrophic forgetting, i.e., a 6% performance degradation on control benchmarks, with 13% in coding.

2026-09-16 04:00:00 · 大模型,AI应用,搜索RAG,微调蒸馏,模型评测,提示工程,长上下文,论文

The Immutable Past: Formalizing State Mutability and Conflict Resolution in Mutable RAG

arXiv cs.CLarXiv:2609.16073v1 Announce Type: new Abstract: Retrieval-Augmented Generation (RAG) serves as the primary memory architecture for long-horizon autonomous agents. However, treating shared memory as an append-only stream introduces \textit{Semantic Shadowing}, a critical failure mode where conflicting historical observations accumulate and statistically dominate valid recent updates. In dynamic environments, this results in severe state divergence as agents retrieve and act upon obsolete facts. This paper formalizes the mechanics of State Mutability to prove that standard dense retrieval suffers from Asymptotic Recall Decay. Furthermore, we formally demonstrate a Majority Vote Trap, revealing that increasing the retrieval context window paradoxically degrades generation accuracy by diluting the attention mechanism under conditions of semantic equivalence. To resolve this, we introduce GC-Mem (Garbage Collection for Memory), a strict inference-time consistency protocol. Unlike heuristic time-decay mechanisms---which indiscriminately destroy valid long-term memory---GC-Mem relies purely on a temporal dominance operator ($\Phi_{\mathcal{T}}$) paired with contradiction detection to surgically excise shadowed context. Evaluated across a rigorous, behaviorally inferred benchmark of 137,760 memory chunks and continuous accumulation sweeps, standard RAG and timestamp re-ranking baselines experience severe degradation. In contrast, GC-Mem empirically recovers $>90\%$ conflict resolution accuracy. We establish strict precision and recall deployment thresholds, ensuring state convergence where standard mutable RAG fundamentally fails.

2026-09-16 04:00:00 · AI应用,Agent智能体,搜索RAG,Transformer,扩散模型,模型评测,长上下文,招聘HR,论文

"Do You Still Read the Code?"

Lobsters

Comments

2026-09-14T00:00:00.000Z · 大模型,算力芯片,AI应用,OpenAI,Google,Anthropic,Agent智能体,推理思考,搜索RAG,Transformer,扩散模型,强化学习,微调蒸馏,长上下文,招聘HR,收购并购,论文

Shared KV Caching for Replicated 27B Inference: Correctness Failures and Performance Boundaries

arXiv cs.LGarXiv:2609.15021v1 Announce Type: cross Abstract: Shared host-memory caching can avoid repeated prefill when a request moves between inference replicas. Its usefulness depends on both correct state transfer and lost prefix locality. We study two single-GPU 27B vLLM replicas sharing a 256 GiB LMCache pool. After adopting an existing packed-page patch, we isolate a raw-pointer fallback that omits the dependency on the current CUDA stream. Controlled byte tests fail under an imposed delay and pass when the dependency is restored; the existing mixed allocator provides a working deployment path. Full-pool allocation checks and service regression complete the validation. A four-block OFF-ON-ON-OFF comparison contains 768 measured requests within two block pairs. Median cross-replica time to first content token falls from 31.715 to 0.605 seconds at 128k input and from 92.047 to 0.790 seconds at 256k. Six-turn synthetic sessions alternating replicas improve by approximately 35% and 45% at initial contexts of 32k and 128k, while fixed placement shows little benefit. This engineering case study identifies practical validation steps and the locality conditions in which shared caching pays off.

2026-09-15 04:00:00 · 大模型,算力芯片,NVIDIA,扩散模型,长上下文,端侧AI,论文

SpectralShift: Effective Context Window Extension of Gated DeltaNet via Spectral Reparameterization

arXiv cs.CLarXiv:2609.14320v1 Announce Type: new Abstract: Recently, linear attention layers have been increasingly adopted to replace softmax attention at scale for long-context modeling. However, existing context extension approaches typically apply continued pretraining directly without modifying these layers, overlooking the spectral properties of linear attention state dynamics. In this work, we study long-context extension of Gated DeltaNet (GDN) from a spectral perspective of transition matrix and identify two essential factors governing long-range information retrieval: (1) a sufficiently broad slow spectral band aligned with the target dependency length, and (2) the preservation of fast-decaying modes for state clearing and context switching. Based on this observation, we propose SpectralShift, a spectral reparameterization approach for long-context continual pretraining of GDNs. Specifically, SpectralShift reparameterizes the alpha projections initialization to reshape the decay spectrum by enhancing slow propagation capacity, and further introduces a learning-rate scaling for alpha projections to facilitate long-context training. Experiments show that SpectralShift consistently improves long-context capabilities over training, providing an effective and efficient solution for extending context windows of linear attention models. The code has been open-sourced at https://github.com/RUCAIBox/GDN-SpectralShift.

2026-09-15 04:00:00 · 开源,Transformer,预训练,长上下文,论文

Concertina: Data-Centric Adaptive Pipeline Parallelism for Efficient Heterogeneous Long-Context LLM Training

arXiv cs.AIarXiv:2509.21275v5 Announce Type: replace-cross Abstract: Long context training is crucial for extending LLM context windows. Existing schemes, such as sequence parallelism, incur substantial communication overhead. Pipeline parallelism (PP) reduces this cost, but its effectiveness hinges on partitioning granularity. Batch-level PP employing sequence packing exhibits high memory consumption in long-context scenarios, whereas token-level PP splitting sequences into slices alleviates memory overhead but may introduce performance degradation. Moreover, the skewed sequence-length distribution in real-world datasets defeats any monolithic, static choice of PP granularity. In this paper, we propose \textit{Dynamic Pipeline Parallelism} (DPP), which transforms PP granularity from a static design choice into a workload-adaptive optimization space over packed, split, and hybrid chunks. DPP further introduces a new coupling between heterogeneous pipeline scheduling and gradient checkpointing. To solve this coupling, \name co-optimizes dynamic chunk scheduling with \textit{Stage-Aware Chunk-Level Adaptive Checkpointing}. Comprehensive experiments demonstrate that \name achieves up to 1.69\texttimes\ speedup over FlexSP and up to 1.40\texttimes\ over MEPipe. The source code is available at https://github.com/wsjdsg/InfiniPipe-code.

2026-09-15 04:00:00 · 大模型,开源,长上下文,论文

VideoScout: Learning Agentic Active Exploration with Adaptive Reasoning Pacing for Long Video Understanding

arXiv cs.AIarXiv:2609.15606v1 Announce Type: cross Abstract: Multimodal Large Language Models (MLLMs) have achieved remarkable progress on short video understanding yet remain limited on long videos due to the limited visual context window. Prevailing approaches rely on uniform frame sampling or recent coarse-to-fine agentic zooming, both of which struggle to localize sparse, decisive evidence in sufficiently long videos. We formulate long video understanding as a \textbf{Sequential Evidence Acquisition (SEA)} problem, in which an agent reads the video turn by turn along the temporal axis, deciding at each turn how fast to watch, what evidence to retain, when to revisit uncertain segments, and when to stop and answer. Inspired by this view, we propose \textbf{VideoScout}, a multi-turn reasoning agent that instantiates the SEA paradigm through adaptive reasoning pacing. Specifically, by dynamically controlling the viewing pace, VideoScout enables efficient traversal of long videos within a bounded visual context window, allowing the agent to access more video content while balancing content analysis depth with reading efficiency. To train VideoScout, we construct VideoScout-66K, a set of over 66K high-quality exploration turns from 10K answer-verified trajectories, and adopt a two-stage pipeline: cold-start supervised fine-tuning teaches the agent per-turn output format, while the Decoupled Clip and Dynamic sAmpling Policy Optimization (DAPO) algorithm performs trajectory-level reinforcement learning with a composite reward that jointly considers answer accuracy, output format compliance, and the temporal alignment between the agent's viewing progress and the teacher's answer timing measured by intersection-over-union (IoU). Extensive experiments on long video understanding and reasoning benchmarks demonstrate that our 7B model achieves strong performance compared with existing trained 7B agentic models.

2026-09-15 04:00:00 · 大模型,算力芯片,AI应用,Google,多模态,Agent智能体,推理思考,强化学习,微调蒸馏,模型评测,模型安全对齐,长上下文,招聘HR,收购并购,榜单评测,论文

Natural Language Knowledge Graph Query Execution: Leveraging Controlled Semantics in the LLM Context Window

arXiv cs.AIarXiv:2609.14652v1 Announce Type: cross Abstract: Large Language Model (LLM) applications often transfer domain concepts into the model's context informally, through prompt prose, schema dumps, and examples. We show that for database queries, data model concepts pass to LLMs more effectively through representations whose vocabulary terms carry declared, machine-readable semantics (controlled semantics). NLKGQ is a working system and reusable framework that does this for data modeled in a knowledge graph. A formal OWL ontology serves as the transfer mechanism, concentrating the meaning of the data into semantically precise tokens the model can use directly. In a single LLM call, NLKGQ places in the context a system prompt instructing on SPARQL, the complete domain OWL ontology, and a domain-specific prompt addition, together with the user's natural language query. The model then generates the SPARQL query directly, zero-shot. Where the native vocabulary of an existing database or federation of databases is opaque, a wrapper ontology substitutes clean terms and a runtime rewriter restores the native forms. Evaluating on DBLP-QuAD 2.0 showed that its scores depend on the graph snapshot, the endpoint used, and the wording of its machine-generated questions, so we propose DBLP-QuAD 3.1, which maintains the intent of 2.0 while making reference results deterministic, revising reference SPARQL where needed, and rewriting the natural language questions, with a frontier model, to state each reference query's intent clearly and completely. We evaluate on the DBLP-QuAD 2.0 benchmark (57.6% Match under deterministic re-scoring), DBLP-QuAD 3.1 (89.9% Match on 1,000 questions), SemOpenAlex (98% Match against a published baseline's 86% on the identical test set), and neuroimaging metadata (100%).

2026-09-15 04:00:00 · 大模型,AI应用,Meta,搜索RAG,扩散模型,强化学习,模型评测,提示工程,长上下文,招聘HR,论文

Overflip: Repetition-Induced Label Flips in Guardrail Models

arXiv cs.AIarXiv:2609.15013v1 Announce Type: new Abstract: Guardrail models are classifiers deployed to screen malicious prompts and responses in LLM-based services. To meet latency constraints, many lightweight guardrails adopt compact Transformer backbones (e.g., DeBERTa) that are trained with short context windows (typically 512 tokens) and rely on bucketed relative positional encodings to process longer inputs. Prior evaluations assume that a guardrail's decision is stable as the input is lengthened. We show that this assumption can fail. We identify Overflip, a repetition-induced instability where repeating a prompt causes the guardrail's prediction to flip (MAL$\to$BEN) as the sequence grows. We conduct experiments on 9 widely used lightweight guardrail models. Five exhibit MAL$\to$BEN flips on a benchmark of 100 prompts, with confidence margins shrinking steadily with repetition. Among these vulnerable models, flip rates range from 8% to 92%, with first flips occurring at roughly 2.6k--9.4k tokens. Our analysis suggests Overflip differs from traditional attention-dilution baselines, which aim to divert the model's attention away from tokens associated with malicious content, shifting it instead toward unrelated content, such as benign padding or shuffling. While Overflip preserves malicious content, it homogenizes token-level attention over repeated structure and induces a distinct, more gradual attention-dispersion trajectory than padding. Moreover, Overflip poses a greater threat to LLM services than traditional attention dilution methods. Because the bypassed prompt remains semantically intact and is still readily understood by downstream business LLMs, it can transmit malicious intent after passing the guardrail. These findings expose repetition as an attack surface for guardrail models and motivate length-robust evaluation and mitigation.

2026-09-15 04:00:00 · 大模型,Transformer,扩散模型,模型评测,提示工程,长上下文,端侧AI,招聘HR,网络安全,论文

OrchSLM: Probing the Dynamics of Small Language Model Orchestration

arXiv cs.AIarXiv:2609.13470v1 Announce Type: new Abstract: Although large language models (LLMs) have demonstrated remarkable capabilities, their reliance on cloud-scale infrastructure poses fundamental challenges for deployment in agentic pipelines, including latency, privacy, connectivity, and substantial computational cost. Small language models (SLMs) offer a compelling alternative: recent studies suggest that many repetitive and narrowly scoped subtasks in agentic workloads may be better served by specialized SLMs than by monolithic LLMs. However, the limited capacity and context windows of SLMs can constrain long-horizon reasoning and interaction-heavy orchestration strategies such as iterative verification and debate. This motivates a complementary, non-interactive paradigm in which heterogeneous SLMs independently generate candidate solutions and a router orchestrates their cached samples without further model interaction. To further understand the mechanisms of such orchestration, we introduce OrchSLM, a routing framework that unifies existing non-interactive orchestration methods and exposes their underlying design choices as controllable parameters. Using OrchSLM as a systematic probe, we reveal how orchestration behavior emerges from diverse knobs, including the task structure, model-pool composition, and multi-agent consensus.

2026-09-15 04:00:00 · 大模型,AI应用,Agent智能体,推理思考,长上下文,论文

Agent Harness vs Agent Framework vs MCP: Which Layer Owns the Loop, State, Tools, Permissions, and Recovery

MarkTechPost

Harness, framework, and MCP get used interchangeably in agent architecture discussions. They are not the same thing. They sit at different layers, own different responsibilities, and increasingly overlap at the edges. This article separates the 3 with 1 question. Which layer owns the execution loop, state, tool transport, permissions, and recovery?

The 3 categories

Agent harness: The harness is the execution system that wraps a model and turns it into a working agent. OpenAI’s Codex as a platform post (August 19, 2026) defines it directly. The harness manages conversation state, streams execution, and uses tools. It also enforces sandbox and approval policies and carries work across turns. Anthropic’s Claude Code docs call the same thing an agentic harness. The Claude Agent SDK exposes ‘the same tools, agent loop, and context management that power Claude Code.’ A harness is opinionated. It ships a loop, a permission model, a sandbox, and a context strategy as one unit.
Agent framework: A framework is a library of primitives for composing agents. It covers model clients, tool abstractions, graph orchestration, memory interfaces, and observability hooks. Examples include LangGraph, the OpenAI Agents SDK, and Microsoft Agent Framework, which reached 1.0 GA in April 2026. A framework gives you the parts and the loop skeleton. You decide the policy.
MCP: The Model Context Protocol is a wire protocol, not a runtime. It standardizes how an LLM application (the host) discovers and calls capabilities exposed by servers: tools, resources, and prompts. MCP uses JSON-RPC 2.0 messages between hosts, clients, and servers. Since December 2025 the Linux Foundation’s Agentic AI Foundation has governed it, alongside goose, AGENTS.md, and now A2A. MCP owns no loop and no agent state. It owns the contract between the agent and its tools.

Ownership matrix

The table maps each responsibility to the layer that owns it by default. “Owns” means the layer defines and enforces the behavior. “Exposes” means the layer surfaces a hook but does not decide policy.

Responsibility	Agent harness	Agent framework	MCP
Execution loop	Owns: Fixed, product-grade loop with turn limits and compaction.	Owns skeleton: You configure termination, handoffs, and turn caps.	None: Request/response only.
Agent state and memory	Owns: Sessions, resume, fork, file checkpointing.	Exposes: Checkpointers, session stores, thread IDs.	None at protocol level since 2026-07-28.
Tool transport	Consumes: Built-in tools plus MCP client.	Consumes: Function tools plus MCP client.	Own: JSON-RPC over stdio or Streamable HTTP.
Permissions and approvals	Owns: Permission modes, hooks, sandbox.	Exposes: Guardrails, interrupts, middleware.	Delegates to host: Cannot enforce.
Recovery	Owns: Session resume, checkpoint rewind, compaction.	Exposes: Durable execution, replay, retries.	Partial: Tasks extension for long-running calls.
Isolation and sandboxing	Owns: OS sandbox, worktrees, containers.	Optional: Hosted sandboxes or micro-VMs.	None.
Multi-agent orchestration	Owns patterns: Subagents, dynamic workflows.	Owns primitives: Graphs, handoffs, fan-out.	None: A2A covers agent-to-agent.

The rest of this article justifies each row with sources.

Who owns the execution loop

Every agent runs a loop. Send context to the model, read the response, execute tool calls, feed results back, repeat. The harness and the framework both implement this loop. They differ in how much you control it.

Harness loop: The Claude Agent SDK documents its loop as 5 steps. Receive prompt, evaluate and respond, execute tools, repeat, return result. Each full cycle is 1 turn, and the loop ends when Claude produces a response with no tool calls. Hooks can intercept, modify, or block tool calls before they run. The loop itself is not yours to rewrite. OpenAI’s Codex harness exposes the loop through app-server, a documented client protocol. Applications create threads, start turns, receive events, and handle approval requests.
Framework loop: The OpenAI Agents SDK loop terminates on final output. It re-runs on handoff, or executes tool calls and continues. Exceeding max_turns raises MaxTurnsExceeded, and a guardrail tripwire raises GuardrailTripwireTriggered. In LangGraph, the loop is whatever graph you draw. Nodes, edges, and conditional routing define control flow.
MCP: MCP has no loop. Since the 2026-07-28 specification, it does not even have a handshake. The initialize/initialized exchange and Mcp-Session-Id header were retired. Every request travels alone, carrying its protocol version and client capabilities in _meta. The host’s loop decides when to call tools/call. MCP only defines what that call looks like on the wire.

Who owns state

Harness: State lives in the harness and persists across sessions. The Claude Agent SDK supports sessions that resume or fork later. File checkpointing restores files to any previous state. Microsoft’s harness layer ships a FileMemoryProvider for session-scoped notes and automatic context compaction that monitors token usage mid-loop. Anthropic’s long-running harness work goes further. It hands off state between context windows through artifacts on disk. Each new session begins with no memory of the last.
Framework: Frameworks expose state primi

2026-09-14 21:54:22 · 大模型,算力芯片,AI应用,具身智能,开源,OpenAI,Google,Anthropic,Meta,Microsoft,代码生成,Agent智能体,搜索RAG,扩散模型,强化学习,提示工程,长上下文,招聘HR,开发者生态

DeepSeek-V4.1-Flash Packs 552B Parameters With Efficient MoE Inference

Hacker Noon

Overview

DeepSeek-V4.1-Flash is a multimodal Mixture-of-Experts model from deepseek-ai that accepts text and images and generates text. Its defining feature is memory and inference efficiency for long, input-heavy workloads: it has 552B backbone parameters but activates 8B parameters per token during prefill and 16B during decoding, supports a context window of up to 1M tokens, and reduces its global KV-cache footprint to 890 bytes per token. The model uses a 40-layer Causal Encoder-Decoder architecture with 20 causal-encoder layers and 20 decoder layers, plus compressed sparse attention, FP4 KV caching, conditional memory, and speculative decoding. It was trained from scratch on a 45T-token multimodal corpus. The repository identifies transformers as the library and image-text-to-text as the pipeline type, but the release does not include a Jinja chat template; production integration requires the supplied Python encoding reference or the separate deepseek-recipe toolkit. The most important practical qualification is that the model is enormous despite its low active-parameter count: the README provides no VRAM requirement, inference-speed figure, weight-conversion command, or hosted pricing, so local deployment requires careful validation against the inference instructions and available hardware.

Best use cases

Long-context coding agents. The model fits repository-scale and multi-step software tasks that need large tool traces, source trees, test output, and documentation in one context. Its 1M-token context, 8B prefill activation, 16B decode activation, bounded sparse indexing, and KV-cache compression target input-heavy agent workloads. At maximum reasoning effort, it scored 90.6 on Terminal-Bench 2.1, 30.0 on Terminal-Bench 3.0, 31.2 on Terminal-Bench 4.0, and 74.2 resolved tasks on DeepSWE v1.1 under the stated harness configurations.

Tool-using research and automation agents. The model supports tool calls through the supplied encoding implementation and deepseek-recipe, which converts Messages, Chat Completions, and Responses API requests into the model’s Conversation format and parses complete or streamed responses. Its agent-focused post-training used automated synthesis of tasks, environments, and rollouts, and its maximum-effort results include 54.8 on AutomationBench, 31.8 on Agent’s Last Exam, 63.9 on HLE with tools, and 88.1 on CyberGym.

Multimodal document understanding. The model can process images alongside text and performs well on document and visual benchmarks. Its reported base-model scores include 95.6 on DocVQA, 77.9 on CVBench, 56.5 on MMMU-Pro, and 86.0 on RefCOCO average Acc@0.5. This makes it suitable for jobs such as extracting fields from scanned forms, answering questions about charts, locating objects in an image, and combining screenshots with written instructions.

Code generation and mathematical assistance. The base model scored 79.4 Pass@1 on HumanEval, 60.6 Pass@1 on BigCodeBench, 93.0 on GSM8K, and 61.1 on MATH. These results support code completion, test generation, debugging assistance, and structured mathematical problem solving. The model does not lead every reasoning benchmark: MGSM reached 80.2, below both comparison base models, and MATH reached 61.1 versus 64.5 for DeepSeek-V4-Pro-Base.

Long-running conversational systems with controllable reasoning cost. Instruct inference exposes reasoning_effort from 1 to 100, allowing an application to trade response cost and latency against accuracy. Use lower settings for routine extraction or short answers and higher settings for coding, planning, and difficult tool tasks. The published instruct evaluations use reasoning_effort=100, temperature=1.0, and top_p=0.95, so lower-effort quality requires application-specific testing.

Limitations

The 552B backbone makes this a demanding local deployment target. The README gives no minimum GPU count, VRAM figure, CPU requirement, quantized checkpoint size, tokens-per-second result, latency result, or practical batch-size guidance. The 8B/16B active-parameter figures do not mean that the full model weights disappear: memory, weight loading, communication, KV cache, and runtime support remain deployment concerns.

The 1M-token limit is a maximum context window, not a guarantee of uniform quality across every position. The reported LongBench-V2 score is 45.2, below DeepSeek-V4-Pro-Base at 51.5 and only slightly above DeepSeek-V4-Flash-Base at 44.7. Long-context applications should test retrieval, instruction following, and tool-state retention at the target context lengths.

Quality varies by task. The base model trails DeepSeek-V4-Pro-Base on AGIEval, C-Eval, MultiLoKo, SimpleQA-Verified, SuperGPQA, BBH, BBEH, DROP, HellaSwag, MATH, MGSM, and LongBench-V2. In maximum-effort agent evaluations, it scores below the listed frontier models on HLE, Terminal-Bench 3.0, Terminal-Bench 4.0, ProgramBench, and several visual benchmarks. Benchmark results also depend on harness, sampling, context limit, number of samples, and network access; they do not predict every production workflow.

The release lacks a Jinja-format chat template. Direct use through a generic chat interface can produce incorrect prompts unless the application uses the encoding reference implementation or deepseek-recipe. The model expects a protocol that can represent thinking, tool calls, images, system messages, and reasoning effort, so integration work is greater than for a model with a standard Transformers chat template.

The model is MIT-licensed, including the repository and weights according to the model card. MIT permits commercial use, modification, and redistribution subject to the license terms, including preservation of copyright and license notices. The provided material does not describe dataset-specific restrictions, safety evaluations, demographic bias, or a deployment policy, so those areas require independent review.

How it compares

DeepSeek-V4-Flash

Choose DeepSeek-V4.1-Flash when multimodal input, stronger code performance, controllable reasoning, and lower persistent KV-cache use matter. It has 552B backbone parameters versus 284B, activates 8B/16B rather than 13B, stores about 890 bytes per token, and reports roughly one-quarter of the global KV-cache footprint of DeepSeek-V4-Flash; its base scores are higher on HumanEval, BigCodeBench, GSM8K, and MMLU-Pro. Choose DeepSeek-V4-Flash when its smaller backbone, simpler deployment path, or lower model-weight burden fits the workload; it scored higher on DROP, MGSM, and matched it on C-Eval, while the provided data does not establish absolute hosted cost or latency for either model.

DeepSeek-V4-Flash

Choose this DeepSeek-V4.1-Flash release when you need the official deepseek-ai checkpoint, its CED architecture, multimodal capabilities, reasoning-effort control, and the documented CSA2 and FP4 KV-cache design. Choose the Unsloth-listed DeepSeek-V4-Flash when that distribution offers a more convenient local packaging or conversion workflow. The supplied information does not provide independent speed, cost, quantization, or quality measurements for the Unsloth distribution, so those differences cannot be confirmed from this model card.

DeepSeek-V4-Flash-DSpark

Choose DeepSeek-V4.1-Flash for the newer architecture and its integrated DSpark speculative deco

2026-09-14 02:50:04 · 大模型,算力芯片,AI应用,具身智能,Google,DeepSeek,多模态,Agent智能体,推理思考,搜索RAG,Transformer,扩散模型,MoE架构,强化学习,微调蒸馏,模型评测,提示工程,长上下文,端侧AI,招聘HR,榜单评测,开发者生态

84GB GDDR7 英伟达RTX PRO 5500 Blackwell专业显卡登场

CnBeta

英伟达官网正式发布RTX PRO 5500 Blackwell专业工作站显卡。RTX PRO 5500采用Blackwell架构，最引人注目的特性是84GB GDDR7显存。该显存支持错误校正码(ECC)，带宽高达1398 GB/秒，可运行更大AI模型、支持更长上下文窗口，并同时运行多个模型而无需卸载到系统内存。

阅读全文

· 算力芯片,NVIDIA,长上下文,招聘HR,模型发布

强化学习大本营新作：如何破解「学新忘旧」困局

雷锋网

阿尔伯塔大学团队提出FAME框架，给持续强化学习一个可求解的公式。

作者丨邓哲敏

编辑丨齐铖湧

今天教会机器人拧瓶盖，明天再让它抓杯子，它可能又把拧瓶盖忘得一干二净。

反观人类，这类现象极少出现。人脑拥有成熟的记忆分工体系，新旧知识有序存储，习得新事物的同时不会冲刷掉旧有认知。

这套终身学习的机制，其实是当下大模型同样欠缺的。Demis Hassabis、梁文锋与 Ilya Sutskever 都指出过大模型的固有短板：通过微调注入新知识时，往往会丢掉过往已经掌握的技能；即便靠超长上下文临时读取新信息，也无法把经验真正固化进模型本体。

灾难性遗忘一直是微调范式下挥之不去的痛点，也由此推动持续学习成为近年来的研究热点，尤其是在 LLM-Agent 赛道，人们希望打造能在部署后不断吸收经验、修正认知，同时保留原有能力的智能体。

眼下，具身的处境十分微妙。宇树上市后市场反响不算热烈，多少折射出具身智能商业化的现实挑战。可越是如此，持续学习对具身的长期价值越躲不过去：机器人要在真实世界干活，若始终“学新忘旧”，那比大模型更致命。

阿尔伯塔大学强化学习团队正是想补上这块基础短板，提出一套基于快速学习加元学习双系统的持续强化学习框架，论文已被 ICRL 2026 收录。AI科技评论（雷峰网公众号）联系到论文的两位共同第一作者张鸿铭、孙科，和他们聊了聊论文背后的思路，以及他们对持续强化学习这个方向的判断。

论文链接：https://arxiv.org/abs/2603.00903

从经验方法走向原则性分析框架

传统强化学习有个默认前提：环境是不变的。奖励函数固定，状态转移固定，智能体只要在一亩三分地里磨到最优就行。

现实世界却完全相反，一个真正具有持续学习能力的智能体需要同时具备两种能力：可塑性，即面对新任务时，可以快速学习并适应；稳定性，即学习新任务之后，仍然能够保留过去已经掌握的知识。

2026-09-15 02:18:00 · 大模型,AI应用,具身智能,Agent智能体,教育学习,强化学习,微调蒸馏,长上下文,传媒内容,榜单评测,论文

EventMemAgent: Hierarchical Event-Centric Memory for Online Video Understanding with Adaptive Tool Use

arXiv cs.CVarXiv:2602.15329v2 Announce Type: replace Abstract: Online video understanding requires models to perform continuous perception and long-range reasoning within potentially infinite visual streams. Its fundamental challenge lies in the conflict between the unbounded nature of streaming media input and the limited context window of Multimodal Large Language Models (MLLMs). Current methods primarily rely on passive processing, which often face a trade-off between maintaining long-range context and capturing the fine-grained details necessary for complex tasks. To address this, we introduce EventMemAgent, an active online video agent framework based on a hierarchical memory module. Our framework employs a dual-layer strategy for online videos: short-term memory detects event boundaries and utilizes event-granular reservoir sampling to process streaming video frames within a fixed-length buffer dynamically; long-term memory structuredly archives past observations on an event-by-event basis. Furthermore, we integrate a multi-granular perception toolkit for active, iterative evidence capture and employ Agentic Reinforcement Learning (Agentic RL) to end-to-end internalize reasoning and tool-use strategies into the agent's intrinsic capabilities. Experiments show that EventMemAgent achieves competitive results on online video benchmarks. The code will be released here: https://github.com/lingcco/EventMemAgent.

2026-09-14 04:00:00 · 大模型,AI应用,开源,多模态,Agent智能体,推理思考,强化学习,模型评测,长上下文,端侧AI,论文

SeDeM: Selective Decompression of Hidden-State Memories for Long-Context Question Answering

arXiv cs.CLarXiv:2608.00311v2 Announce Type: replace Abstract: Long-context inference with large language models (LLMs) is costly: self-attention during prefill scales quadratically with sequence length, and the key-value (KV) cache grows with the number of processed tokens. Larger context windows also do not ensure reliable evidence use. Context compression reduces this cost, but many soft-compression methods use LLMs as compressors and rely on compact memory tokens both to preserve information and to condition the decoder. We propose SeDeM, a selective decompression framework that decouples compact memory storage from decoder conditioning. SeDeM stores context as compact hidden-state memory blocks, selects query-relevant blocks, and decompresses only the selected blocks for decoder conditioning. Thus, the decoder avoids both full-context processing and direct generation from highly compressed memory slots. On four long-context QA benchmarks, SeDeM achieves higher QA scores than the compression baselines in our main comparison in both 1B and 3B same-backbone settings, and with the 3B backbone exceeds full-context fine-tuning on three datasets. SeDeM also provides favorable quality--efficiency trade-offs, achieving 1.74--2.46$\times$ lower online time-to-first-token and 1.08--1.10$\times$ higher autoregressive decoding throughput relative to ICAE while maintaining strong answer quality.

2026-09-14 04:00:00 · 大模型,AI应用,搜索RAG,Transformer,扩散模型,微调蒸馏,模型评测,长上下文,招聘HR,论文

Doc2FRC: Length-Consistent Document-Level Machine Translation via Fixed-Range Chunking

arXiv cs.CLarXiv:2609.12674v1 Announce Type: new Abstract: Advanced large language models (LLMs) with long context windows can substantially reduce input truncation in document-level machine translation (DocMT). However, direct Doc2Doc translation remains prone to n-gram repetition and progressive quality degradation. A common remedy is to segment the document into finer-grained chunks. Nonetheless, conventional rule-based chunking approaches fail to handle the length distribution mismatch between training and inference. To address this, we introduce Fixed-Range Chunking (FRC), utilizing dynamic programming to partition documents into chunks within a predefined length interval. By consistently applying FRC during training and inference, the input documents of any length are mapped to the same length distribution, substantially reducing train-test length mismatch. Centered on FRC, we propose a lightweight dual-boundary matching algorithm for chunk alignment, alongside four distinct training strategies. Experimental results show that FRC-based fine-tuning substantially improves 7B LLMs over direct Doc2Doc fine-tuning and outperforms existing DocMT methods on IWSLT2017. We further construct GlobVDoc, a 10-language test set independent of mainstream DocMT training sources, and show that FRC improves out-of-distribution document translation.

2026-09-14 04:00:00 · 大模型,微调蒸馏,模型安全对齐,长上下文,端侧AI,论文

Graph-of-Skills: Dependency-Aware Structural Retrieval for Massive Agent Skills

arXiv cs.AIarXiv:2604.05333v4 Announce Type: replace Abstract: As LLM agents act across personal applications, web browsers, and other interfaces, their reusable skill libraries can scale to thousands of skills. This scale introduces two challenges. First, loading the full library saturates the context window, driving up token costs, hallucination, and latency. Second, semantic retrieval surfaces topically relevant skills but can miss upstream and downstream prerequisite skills, creating a prerequisite gap that leaves the retrieved bundle insufficient for execution. We present Graph-of-Skills (GoS), an inference-time structural retrieval layer for large skill libraries. GoS constructs an executable skill graph offline from skill packages, then retrieves a bounded, dependency-aware bundle through hybrid semantic-lexical seeding, reverse-aware Personalized PageRank, and context-budgeted hydration. Across SkillsBench and ALFWorld, with three model families (Claude Sonnet 4.5, MiniMax M2.7, and GPT-5.2 Codex), GoS attains the highest average reward in all six model-benchmark blocks, at a fraction of the token cost of loading the full library. On SkillsBench with GPT-5.2 Codex it raises average reward by 7.0 absolute points over full skill loading, a 25.6% relative gain, while cutting total tokens by 56.7%. Ablations isolate the mechanism: replacing reverse traversal with forward propagation costs 9.1 reward points, a larger loss than removing the graph altogether. The gain thus comes from traversing dependencies backwards, not from graph diffusion as such. A budget-matched retrieval study holding seeding, reranking, hydration, and context budget fixed reproduces the same ordering, with dependency-pair co-recovery falling from 0.654 to 0.362. Code is available at https://github.com/davidliuk/graph-of-skills

2026-09-14 04:00:00 · 大模型,AI应用,开源,OpenAI,Anthropic,代码生成,Agent智能体,搜索RAG,扩散模型,模型评测,模型安全对齐,长上下文,招聘HR,榜单评测,论文

继续滚动加载更多…