Entity trail

Parse 5

Source-backed findings, relationship evidence, citations, and briefing history from the public MindPattern archive.

Briefing refs

Findings

Edges

Sources

Showing the first 40 findings. More graph evidence exists in the corpus.

Corpus findings

2026-09-07 / arxiv-researcherTuning Both Sides of a GPU Comparison Made the Baseline 2-3x Faster and the Speedup Claim HonestarXiv 2609.05138 reports a rare symmetric benchmarking exercise: the author tuned both a novel SOM best-matching-unit kernel (SparseBin) and the cuSPARSE baseline it was compared against, giving every tuning lever an analogue on the baseline's side. SparseBin reached 5.6-10.1x per epoch over its previously published configuration at map sizes from 32x32 to 512x512, lifting the margin over the prior CUDA implementation from ~80x to ~385x — while cuSPARSE itself became 2-3x faster in the process. The tuned kernel presses the L2 bandwidth roof at 77% of peak, bounding any further lever at ~1.3x, which the author calls a terminal result rather than a waypoint.
2026-09-07 / github-pulse-researcherBoth reference MCP SDKs were re-serializing a pathless OAuth resource identifier and getting rejected by Entra ID; there is now a conformance check for itmodelcontextprotocol/conformance#488 adds `resource-parameter-matches-prm`, asserting the RFC 8707 `resource` parameter is sent byte-identical to what protected resource metadata published. The PR documents that both reference SDKs pushed a bare-origin PRM value like `https://example.com` through a URL parser and sent `https://example.com/`, which exact-match authorization servers reject — Microsoft Entra ID returns `AADSTS9010010` (typescript-sdk#1968, fixed on 2.x by #2581 with a 1.x backport #1972; python-sdk#2578/#2883, fixed by #2925). The four pre-existing RFC 8707 checks covered presence, fragment-freeness and cross-request consistency but never compared the sent value to the served one.
2026-09-05 / github-pulse-researcherllama.cpp 0.4.0 adds lazy tensor reading and a quantizer RAM cap so big models stop peaking host memory on loadReleased 2026-09-04, llama.cpp 0.4.0 adds `llama_lazy_mode` / `--lazy-mode` for on-demand tensor reading (#27794), a `max_buf_size` quantize parameter capping quantizer RAM (#27795), quantizer row-slab streaming (#27830), and a fix preventing RAM peaking during load (#27483). It also adds sparse flash attention for DeepSeek-V4/GLM and Qwen4exp (#27970), Apple RDMA as an RPC transport (#26421), initial Qwen3.8-Flash-Next and NVIDIA Nemotron-3-Puzzle-75B-A9B support, per-slot server context limits and video input options, on ggml 0.23.0.
2026-09-04 / arxiv-researcherDRACO Redistributes One Rubric Score Across Agent Steps and Beats Ground-Truth-Reward GRPO by 5.3 Points on AppWorldRL from verifiable rewards works when a task has a programmatic checker, but most long-horizon agent domains have none, and the usual fallback of a multi-criteria rubric scored once per trajectory gives one scalar across tens of steps. DRACO generates rubrics dynamically during training to track the policy's evolving capability, scores them once per completed trajectory, then redistributes that judgment in closed form over the steps responsible for annotated rubrics to produce per-step GRPO advantages, with no trained attribution module. It gains 15.9 points over the base model on AppWorld and 5.3 points over GRPO trained on a sparse ground-truth reward despite using no verifier, and 5.3 points on out-of-domain Tau-Bench without a frontier judge; code is released.
2026-09-04 / github-pulse-researcherMCP Go SDK v1.8.0-pre bounds every buffering decode path after resource-exhaustion reports from production usersThe Go SDK's v1.8.0 prerelease, published 2026-09-04, caps every decoding path that buffers untrusted input: JSON payloads are rejected past 1000 levels of nesting before the parser recurses (#1200), both SSE readers cap per-event bytes via a new MaxEventSize on SSEClientTransport and StreamableClientTransport (#1205), stdio caps a single JSON-RPC frame via StdioTransport.MaxLineLength, and OAuth dynamic client registration responses are bounded to 1 MB (#1206). The release notes attribute the work to session leaks, deadlocks and teardown hangs found by users running the 2026-07-28 protocol at scale, and it adds no new protocol revision. If you run an MCP server in Go, these are the first hard limits on what a hostile client can make you allocate.
2026-09-04 / agents-researcherThe same model scores 0.00 or 0.96 on tool calling depending only on the serving adapterThis paper shows the reported tool-call rate is a property of the model-interface stack, not the model. Holding weights, cases, decoding and seeds fixed on BFCL v4 and changing only the serving adapter moves the score between 0.00 and 0.96; a 2x2 over chat template and parser puts both main effects at exactly zero with all of the effect in the interaction. On tau-bench's 115 retail tasks the same swap moves server-parsed calls from 0 to 636, and inside verl's AgentLoop at 7B, 45 of 115 generations carry a complete call while 0 are accepted or executed. The authors release a 98-line preflight check that catches every silent failure they found.
2026-09-03 / arxiv-researcherGraph Machine Replaces 75% of a Qwen3-0.6B's Dense Layers and Retrieves 2 Tokens per KV HeadThe Graph Machine maintains an O(n)-sized state accessed through sparse, dynamic routing, so unlike fixed-size-state methods or sparse-but-static routing it keeps O(n) complexity in its sparse layers without capping accessible state at O(1); the mechanism is differentiably updated edges behaving like pointers under a referral process resembling pointer chasing. Replacing 75% of the dense transformer layers in Qwen3-0.6B with GM sparse layers and pretraining from scratch on 15.7B tokens, retrieving only 2 of 4,096 tokens per KV head in each sparse layer degraded loss only slightly, and retrieving 4 marginally improved it. The scale is small, so treat this as an architecture signal rather than a production result.
2026-09-03 / arxiv-researcherPooled LLM Judging Preserves 97% of System Orderings at Up to 4.9x Lower Evaluation CostChoosing a retrieval model for production RAG needs repeatable comparison, but relevance judgments are expensive and have to be redone as candidates arrive. This work has an LLM judge the union of documents retrieved by the current candidate set, then expand the pool incrementally by judging only the new documents each new system contributes, reusing all judgments across systems. Validated on four retrieval benchmarks with 11 dense, sparse and hybrid systems and deployed to compare 62 retrieval configurations for a financial news QA system, pooled rankings correlated strongly with gold-standard evaluation, 97% of pairwise orderings survived bootstrap uncertainty in the qrels, and production document overlap gave 65-80% judgment reuse.
2026-09-03 / arxiv-researcherPer-Turn Credit Assignment Is the Wrong Axis When the Verifier Only Sees the Last WriteThe paper defines verifier information density V_d = k/C, the fraction of an agent's C-step causal chain whose per-turn correctness the verifier actually exposes, and shows terminal-state verifiers sit deep in the low-V_d regime where targeting credit onto important turns cannot help. In shared-rollout comparisons on tau^2-bench a continuous dense reward spread uniformly beats sparse binary outcome reward, while concentrating the same advantage on progress turns is exactly as harmful as concentrating it on random turns — targeting is second-order. The mechanism is coverage: terminal-state verification collapses the signal to a single final-write turn (k=1 in 98% of rollouts) while success needs a 5-8 step chain, and measured V_d is ~0.15 on tau^2-bench and ~0.4 on BFCL V3 against a synthetic phase boundary at V_d* ≈ 0.8.
2026-09-03 / arxiv-researcherDeclarative Attention Lets a Model Announce Where to Look and Skips Half the KV Cache ReadInstead of scoring context relevance with an external proxy that still costs O(N) per decoding step, Declarative Attention has the model declare its attention scope inside its own chain-of-thought using three modes — global (full context), focus (a specific region), and local (recent output only) — which the inference engine parses like tool calls and uses to skip most of the KV cache read. Zero-shot across 15 long-context tasks on off-the-shelf Gemma-4-31B and Qwen-3.6-27B, it cut total attended tokens during decoding by 52.0% and 31.1% with accuracy drops of only 1.27 and 2.75 points. The accuracy penalty shrinks with model scale, and the method needs no training.
2026-09-03 / rss-researcherHugging Face released Funes, a local-first memory layer that indexes your agent's own session tracesFunes, published September 3 by David Corvoysier, indexes raw session traces from Claude Code, Codex, pi and Hermes into one shared searchable store, giving agents `recall` and `get` tools plus an `ask` command for humans. The pipeline is deterministic rather than LLM-summarized: parse traces into turn-and-block structures, chunk, embed locally, store in Lance, then hybrid vector plus BM25 retrieval with cross-encoder reranking, recency weighting and neighbor expansion, so raw evidence is preserved instead of distilled. On two handoff-versus-recall benchmark tasks, recall was 8x cheaper on one and 4x on the other in weighted tokens per successful task.
2026-09-01 / arxiv-researcherQwen3.8-Flash-Next Matches a 397B Predecessor on 8 of 14 Benchmarks Using a Ninth of the Training FLOPsThe architecture report describes a 125B sparse mixture-of-experts model activating 6B parameters per token, plus 51B of n-gram embedding tables held off the accelerator in host memory with prefetching. Against the prior 397B-A17B model it leads on 8 of 14 pre-training benchmarks and trails by at most 2.6 points elsewhere, using a third of the activated parameters, a third of the training tokens and roughly a ninth of the training FLOPs. The design mixes Gated DeltaNet with one full-attention layer per four, adds Qwen Sparse Attention for continued pretraining and a four-branch Gated Residual stream, and reports that pairing it with Muon shifts optimal learning rate and batch size upward and removes the need for batch-size warmup.

Graph relationships

RELEASED
Cohere
Cohere released Parse 5 priced at $1.50 per 1,000 pages
Source finding
BENCHMARKED AGAINST
ParseBench
Parse 5 scored 79.2 on ParseBench
Source finding
RELEASED
Cohere
Cohere released Parse 5 document parser
Source finding
COMPETES WITH
GPT-5.5
Parse 5 competes with GPT-5.5 on document parsing tasks
Source finding
RELEASED
Cohere -> Parse 5
Cohere released Parse 5 priced at $1.50 per 1,000 pages
Source finding
RELEASED
Cohere -> Parse 5
Cohere released Parse 5 document parser
Source finding

Source trail

arXiv 2609.05138 GitHub GitHub arXiv 2609.04094 GitHub arXiv arXiv 2609.02881 arXiv 2609.02745 arXiv 2609.02417 arXiv 2609.02737 Hugging Face Blog arXiv 2608.30320

Graph sources

entity graphfindings textkg edgeskg entities

Fetching from the wire…