DEV Community: cz

Gesture Synth Weld Vercel App 2026: How a Webcam Becomes a Synthesizer

cz — Sun, 16 Aug 2026 14:06:00 +0000

Gesture Synth Weld Vercel App 2026: How a Webcam Becomes a Synthesizer

🎯 Core Takeaways (TL;DR)

The weld vercel app that took the web by storm is Gesture Synth — a browser-based musical instrument at gesture-synth-weld.vercel.app that turns your webcam into a real-time synthesizer using hand gestures, with zero downloads and zero installs.
Under the hood, the synth weld vercel app runs MediaPipe Hand Landmarker (two hands, 21 landmarks each) to classify finger patterns into chords, while a Web Audio API signal chain — oscillators → wave shaper → biquad filter → master gain — produces the sound entirely in the browser.
The gesture vocabulary is musical, not arbitrary: the left hand picks the chord degree (I–VII via finger counts and 🤘/🤟 shapes), the right hand controls voicing and expression, and hand tilt sweeps the filter from acoustic warmth to EDM squelch.
The gesture synth engine maps every hand state to a deterministic musical result: finger count → Roman numeral, middle-MCP position → major/minor quality, wrist tilt → filter frequency and resonance, with smooth setTargetAtTime transitions that eliminate audio clicks.
The gesture synth weld vercel project is open source (88+ stars on GitHub), built with Vite, and free for educational and non-commercial use — a perfect case study for anyone exploring the gesture synth weld vercel app pattern of camera + Web Audio.

What Is the Weld Vercel App?
Why Gesture Synth Went Viral
How the Gesture Synth Tracks Your Hands
The Synth Engine: Web Audio API Signal Chain
Gesture-to-Chord Mapping
Filter Sweeps and Expression
The Three Synth Presets
Performance and Browser Constraints
FAQ
Conclusion

What Is the Weld Vercel App?

The weld vercel app in question is Gesture Synth, a camera-based musical instrument created by Eric Wei and deployed at gesture-synth-weld.vercel.app. Open the URL, click to enable audio and grant camera access, and your hands become a synthesizer: move them in front of the webcam to change chords, sweep filters, and shape distortion in real time. There is no download, no account, and no MIDI controller — just a browser, a webcam, and the gesture synth engine running entirely client-side.

The name comes from the deployment slug: the synth weld vercel app is the "weld" of "gesture-synth" and "weld" in the Vercel project URL. For SEO purposes, the gesture synth weld vercel combination is what people actually search for when they see the app on social media and want to find it again — which is why this guide covers the full keyword family: gesture synth weld vercel app, gesture synth weld, and the primary weld vercel app phrase.

The app itself is deceptively simple on the surface. A dark stage fills the screen, your webcam feed is processed invisibly, and a chord display shows what you are playing. Twelve keys (A through G#/Ab) let you pick a root, three synth presets change the character of the sound, and a filter control shows the current sweep position. But underneath, the gesture synth is a carefully engineered pipeline of hand tracking, gesture classification, and Web Audio synthesis — and that is what this article dissects.

💡 Professional Tip: The weld vercel app pattern — a single-page Vite app deployed on Vercel with MediaPipe and Web Audio — is a template you can reuse for your own camera-based tools. The entire implementation is open source on GitHub (ericwei97-cloud/gesture-synth).

Why Gesture Synth Went Viral

The gesture synth weld vercel app went viral for a simple reason: it is a demo you can understand in five seconds and play for an hour. The Instagram tutorial posted by the creator shows exactly how it works — left hand picks the chord, right hand shapes the sound — and the immediacy of "your webcam is now a synthesizer" is the kind of moment people share.

There is also a deeper pattern at work. The gesture interaction model removes the last barrier between a person and an instrument: no keyboard, no mouse, no touchscreen. You move your body and music comes out. That is the same reason the gesture synth genre keeps producing viral hits — from gesture-controlled theremins to hand-tracking drum machines — and why the synth weld vercel app deployment model (free hosting, instant load, no install) is the perfect vehicle for it.

For developers, the viral moment matters less than the architecture. The gesture synth weld vercel project demonstrates that a production-quality musical instrument can run entirely in the browser: MediaPipe's Hand Landmarker delivers 21 landmarks per hand at interactive frame rates, and the Web Audio API synthesizes chords with sub-millisecond scheduling. No server, no native code, no app store. That is the gesture synth weld vercel app lesson: the browser is now a musical instrument platform.

How the Gesture Synth Tracks Your Hands

The gesture synth uses MediaPipe Hand Landmarker from @mediapipe/tasks-vision (v0.10.35), configured with numHands: 2 and a 640×480 video input. Each hand is reduced to 21 landmarks — wrist, four finger MCP/PIP/DIP joints, and fingertips — and the gesture synth logic reads those landmarks to classify what your hand is doing.

The classification functions in the source are precise and readable:

isThumbExtended() compares the thumb tip's x-coordinate to the thumb IP joint, with handedness-aware direction (a right-hand thumb extends to the right, a left-hand thumb to the left).
isFingerExtended() checks each finger's extension state.
getChordQuality() compares the middle finger MCP joint to the wrist: if the MCP is to the right of the wrist, the chord is minor; otherwise major. This is the gesture that flips a chord's mood.
classifyChord() combines the five finger states into a Roman numeral: one finger → I, two → II, three → III, four → IV, five → V, and the index+pinky shapes (🤘 and 🤟) → VI and VII.

The result is a deterministic mapping from hand shape to scale degree. Because the gesture synth reads raw landmark positions rather than relying on a gesture classifier model, the logic is transparent, debuggable, and fast — every frame produces a decision with no ambiguity.

The Synth Engine: Web Audio API Signal Chain

The sound of the gesture synth weld vercel app comes from a classic Web Audio API signal chain, built lazily on first user interaction (browsers require a user gesture before audio can start):

oscillators → waveShaper (distortion) → biquadFilter (lowpass) → masterGain → destination

The SynthEngine class in the source creates the chain in ensureContext():

WaveShaperNode with oversample: "4x" — the distortion stage, with 4× oversampling to reduce aliasing harshness.
BiquadFilterNode — a lowpass filter, base frequency 1200 Hz, Q 0.7.
GainNode — the master volume, starting at 0 and ramped smoothly.

When a chord is played, playNotes() stops the previous oscillators and creates one OscillatorNode per note frequency, connecting each to the wave shaper. The current chord is deduplicated by its frequency key, so repeated frames do not restart the sound. Volume changes use setTargetAtTime with a 0.03 time constant, and filter changes use 0.04 — the gesture synth deliberately smooths every audio parameter update to eliminate the clicks and zipper noise that plague naive Web Audio implementations.

Gesture-to-Chord Mapping

The musical core of the gesture synth is the mapping from hand state to chord. The left hand selects the scale degree, and the right hand selects the voicing and expression. The scale is built from semitone offsets in a major scale, and the chord quality (major/minor) comes from the middle-MCP-vs-wrist gesture described above.

Fingers Extended	Gesture	Scale Degree	Chord
1	1️⃣	I	Root chord
2	2️⃣	II	Second degree
3	3️⃣	III	Third degree
4	4️⃣	IV	Fourth degree
5	5️⃣	V	Fifth degree
Index + pinky	🤘	VI	Sixth degree
Index + pinky + thumb	🤟	VII	Seventh degree

The right hand adds voicing variations: four finger configurations produce major, minor, dominant, and diminished voicings — the diminished case even uses a tritone (diminished fifth) for the Diminished 7th chord, a detail that shows the gesture synth author thought carefully about music theory, not just hand tracking. The left hand's tilt mode switches the whole scale between major and minor, so the same gesture vocabulary produces very different music depending on context.

Filter Sweeps and Expression

The most expressive control in the gesture synth weld vercel app is the filter sweep, driven by hand tilt. getHandHorizontalTilt() computes the wrist's position relative to the middle and ring finger MCP knuckles, with a dead zone in the middle and a MAX_TRAVEL of 0.12 before the tilt saturates at ±1.0.

The tilt then drives the filter in two directions:

Inward tilt (negative): the filter frequency drops from 1200 Hz down to 250 Hz, and Q rises to 2.2 — an acoustic, woody warmth.
Outward tilt (positive): the filter frequency rises to 5000 Hz and Q spikes to 5.2 — a resonant, synthetic "squelch" straight out of EDM.

The gesture synth also uses tilt shakiness to drive a jitter effect: random noise is scaled by how much the right hand is shaking, turning nervous energy into audible texture. And the on-screen energy visualization colors the display by chord — major chords glow at full opacity, minor chords damp to a moody 45% — so the visual feedback matches the musical mood.

The Three Synth Presets

The synth weld vercel app ships three oscillator presets that change the character of the sound:

Preset	Character	Waveform Family
Warm Synth	Soft, rounded, pad-like	Mellow waveforms
Bright Synth	Clear, cutting, lead-like	Brighter waveforms
Retro Synth	Classic, video-game feel	Square-ish, chiptune flavor

The preset selects the OscillatorNode waveform used by playNotes(), and because the rest of the chain (distortion, filter, gain) is shared, switching presets changes the timbre without breaking the gesture controls. This is a clean example of separating the control layer from the synthesis layer — the same hand gestures drive every preset.

Performance and Browser Constraints

A camera-based instrument has hard real-time constraints, and the gesture synth weld vercel app handles them with a few deliberate choices:

Client-side everything. MediaPipe runs in the browser via WebAssembly; no frames leave the device, which keeps latency low and privacy intact.
Cover-crop video. The app computes a "cover" crop rectangle in source-video pixel space, so the webcam feed fills the stage without distortion — a detail that matters for both visuals and landmark stability.
Frame-by-frame smoothing. Every audio parameter update uses setTargetAtTime or linearRampToValueAtTime, preventing clicks even when the filter sweeps at full speed.
Lazy audio context. The AudioContext is created only after the user clicks, satisfying browser autoplay policies and avoiding wasted resources.

The gesture synth also integrates Vercel Analytics and Speed Insights plus Microsoft Clarity, so the creator can watch how people actually play — a reminder that even a viral weld vercel app is a product with metrics.

FAQ

Q: What is the weld vercel app?

A: The weld vercel app is Gesture Synth, a browser-based musical instrument at gesture-synth-weld.vercel.app that uses your webcam and hand gestures to play real-time synthesizer chords, pads, and audio loops. The "weld" comes from the Vercel deployment slug of the gesture synth weld vercel app.

Q: How does the gesture synth work?

A: The gesture synth uses MediaPipe Hand Landmarker to track 21 landmarks per hand, classifies finger patterns into scale degrees (I–VII), and synthesizes chords with the Web Audio API. The left hand picks the chord, the right hand controls voicing and expression.

Q: Do I need to install anything to use the gesture synth weld vercel app?

A: No. The gesture synth weld vercel app runs entirely in the browser — no downloads, no accounts, no MIDI hardware. You only need a webcam and permission to use it.

Q: What gestures control the music?

A: Finger counts select scale degrees (1–5 fingers → I–V, 🤘 → VI, 🤟 → VII), the middle-finger position flips major/minor, and hand tilt sweeps the filter from warm to squelchy. The gesture vocabulary is shown in the in-app guide.

Q: Is the gesture synth open source?

A: Yes. The gesture synth weld vercel project is open source on GitHub (ericwei97-cloud/gesture-synth, 88+ stars), built with Vite, and free for educational and non-commercial use with credit to the original creator.

Q: Can I build my own synth weld vercel app?

A: Absolutely. The pattern is: MediaPipe Hand Landmarker for tracking, Web Audio API for synthesis, Vite for building, and Vercel for hosting. The gesture synth weld vercel app is a complete reference implementation to learn from.

Conclusion

The weld vercel app known as Gesture Synth is more than a viral demo — it is a complete, open-source case study in browser-based musical instruments. MediaPipe Hand Landmarker turns a webcam into a two-hand controller, a deterministic gesture vocabulary maps hand shapes to chords, and a carefully smoothed Web Audio API chain turns those chords into music without a single click or pop.

For developers, the takeaways are concrete. The gesture synth weld vercel app shows how to structure a real-time camera pipeline, how to map landmarks to musical decisions, and how to keep audio glitch-free under continuous control. The synth weld vercel app deployment model — free hosting, instant load, no install — is the reason the demo spread so fast, and the same pattern applies to any camera-based tool you want to ship.

If you have not tried it, open gesture-synth-weld.vercel.app, grant camera access, and play. Then read the source, fork it, and build your own gesture synth weld instrument — the browser is ready, and so is the gesture synth weld vercel app template.

Originally published at: Gesture Synth Weld Vercel App 2026: How a Webcam Becomes a Synthesizer

Qwen3.8-27B (2026): The Complete Guide to Qwen's New 27B Vision-Language Model

cz — Sat, 15 Aug 2026 12:18:38 +0000

Qwen3.8-27B (2026): The Complete Guide to Qwen's New 27B Vision-Language Model

🎯 Core Takeaways (TL;DR)

Qwen3.8-27B is the new 27-billion-parameter dense model from Alibaba's Qwen team — a native vision-language model that understands images and videos, with flexible thinking control and Apache 2.0 open weights.
The headline is agentic performance at local-model size: Qwen3.8-27B scores DeepSWE 1.1 at 42.2 (up from 13.3 for Qwen3.6-27B), Terminal Bench 2.1 at 73.0, and beats Claude Opus 4.6 Max on SWE-bench Pro, QwenSWEBench, LiveCodeBench v6, OSWorld, and AndroidWorld.
Qwen3.8-27B ships with a native 262,144-token context window (extensible to 1M via YaRN), 28B BF16 weights, thinking mode on by default, and reasoning_effort levels of xhigh/medium/low.
On OpenRouter, Qwen3.8-27B is available at $0.45 / $3.20 per million tokens — and Reddit users are already running it locally on RTX 3090s, dual RTX 5080s, and 16GB VRAM cards.

What Is Qwen3.8-27B?
Qwen3.8-27B Architecture & Specs
Qwen3.8-27B Benchmarks: The Agentic Leap
Qwen3.8-27B Pricing & API Access
Running Qwen3.8-27B Locally
Qwen3.8-27B vs the Competition
FAQ

What Is Qwen3.8-27B?

Qwen3.8-27B is the newest member of the Qwen3.8 generation — "the most capable generation in the Qwen open-model family to date," per the official model card. Built on the architectural foundation of Qwen3.5, Qwen3.8-27B delivers substantial gains across coding, professional work, research, and long-horizon agentic tasks, packed into a compact, deployment-friendly dense model.

The key word is dense. Unlike the giant Qwen3.8-Max (2.4T-parameter MoE) that grabbed headlines when its weights landed on August 8, 2026, Qwen3.8-27B is a 27B-parameter dense model designed to run on hardware individuals actually own. As the r/LocalLLaMA release thread put it, Qwen3.8-27B is a "renewal of the beloved Qwen model, delivering unmatched intelligence density."

Qwen3.8-27B is also a native vision-language model: it understands images and videos out of the box — from STEM diagrams and documents to hour-scale videos. It's the first Qwen model in this class with full multimodal input and the flexible thinking control that the community has wanted since the GPT-OSS era: "FINALLY! I waited since GPT-OSS for other local model that natively has low and medium reasoning! High for planning, low for execution and exploration," one Redditor wrote.

💡 Professional Tip: Qwen3.8-27B is hosted on Hugging Face at Qwen/Qwen3.8-27B (9.47K likes, ~92K downloads/month, 319 quantization variants) and ModelScope. A hosted version on Qwen Cloud is coming soon with 1M context by default and built-in tools.

Qwen3.8-27B Architecture & Specs

Here's what's under the hood of Qwen3.8-27B:

Spec	Qwen3.8-27B
Model type	Causal LM with vision encoder
Parameters	27B (BF16, ~28B weights on disk)
Hidden dimension	5,120
Layers	64
Hidden layout	16 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))
Linear attention heads	48 V / 16 QK (Gated DeltaNet), dim 128
Attention heads	24 Q / 4 KV (Gated Attention), dim 256
FFN intermediate dim	17,408
Multi-token prediction	Trained with multiple steps
Native context	262,144 tokens
Extensible context	Up to 1,000,000 tokens (YaRN)
License	Apache 2.0
Inputs	Text, image, video
Outputs	Text

The hybrid architecture combines Gated DeltaNet (linear attention for cheap long-context processing) with Gated Attention layers, plus multi-token prediction (MTP) for faster decoding. Qwen3.8-27B supports thinking mode on by default, with reasoning_effort tunable between xhigh (default), medium, and low, and preserve_thinking retaining reasoning context across turns — a design that the model card says "improves KV cache utilization, optimizing inference efficiency in both thinking and non-thinking modes."

For ultra-long work beyond 262K tokens, Qwen3.8-27B recommends YaRN RoPE scaling with a factor of 4.0 (or 2.0 if your typical context is ~524K) — supported in vLLM, SGLang, and TokenSpeed.

✅ Best Practice: For agentic tasks on Qwen3.8-27B, allocate generous output lengths: up to 262,144 tokens for reasoning content and 131,072 for the final response. Lower reasoning_effort doesn't always reduce total task time — insufficient analysis leads to more retries.

Qwen3.8-27B Benchmarks: The Agentic Leap

The reason Qwen3.8-27B broke the r/LocalLLaMA release thread with comments like "That DeepSWE leap — do we have a new local coder champion?" is the sheer size of its gains over the previous generation. Here are the official text benchmarks (Claude Code harness where noted):

Benchmark	Qwen3.8-27B	Qwen3.6-27B	Qwen3.7-Plus	Opus 4.6 Max
Terminal Bench 2.1 (Terminus)	73.0	63.4	64.0	78.2
SWE-bench Pro	61.7	53.5	57.6	53.4
NL2Repo-Bench	42.3	36.2	41.1	47.6
DeepSWE 1.1	42.2	13.3	14.2	–
QwenSWEBench	79.0	49.3	59.2	63.8
CoWorkBench	70.7	61.0	65.1	68.2
JobBench	33.4	21.8	27.6	–
Agents' Last Exam (score)	42.9	27.3	33.6	–
IFBench	79.5	69.1	79.1	62.5
GPQA Diamond	89.2	87.8	90.3	91.3
HLE	30.8	24.0	34.7	40.0
LiveCodeBench v6	90.3	83.9	89.6	88.8

The DeepSWE number is the standout: Qwen3.8-27B more than tripled its predecessor's score (13.3 → 42.2) and outperformed Opus 4.6 Max on SWE-bench Pro, QwenSWEBench, CoWorkBench, and LiveCodeBench v6 — despite being a fraction of the size. Independent leaderboards are already matching the model card: datacurve's DeepSWE leaderboard lists Qwen3.8-27B at 42.2 and ScaleAI's SWE-bench Pro at 61.7.

Where Qwen3.8-27B truly separates from other local models is multimodal agents:

VL Benchmark	Qwen3.8-27B	Qwen3.6-27B	Opus 4.6 Max
OSWorld-Verified (computer use)	84.3	63.9	72.7
WebArena-Verified (browser)	64.8	48.8	–
AndroidWorld (mobile)	81.9	70.3	62.0
RecreationBench	47.1	29.8	–
ClawEval-MM (Pass@3)	57.4	42.6	52.5
SWE-MM	38.6	25.7	27.1
Vision2Web	62.9	45.0	–
MathVision (with CI)	94.6	85.1	65.5
CharXiv (with CI)	90.2	78.4	85.9
OmniDocBench 1.5	91.1	89.4	86.6
RealWorldQA	85.9	84.1	73.9
ERQA	65.5	62.5	40.8

Qwen3.8-27B beats Opus 4.6 Max on OSWorld, AndroidWorld, SWE-MM, MathVision, CharXiv, OmniDocBench, RealWorldQA, and ERQA — computer use, mobile use, document intelligence, and embodied perception, all in a model that fits on consumer GPUs.

Qwen3.8-27B Pricing & API Access

Qwen3.8-27B is live on OpenRouter as qwen/qwen3.8-27b:

Pricing Metric	Qwen3.8-27B
Input / 1M tokens	$0.45 (weighted avg $0.4499)
Output / 1M tokens	$3.20 (weighted avg $3.199)
Context window	262K
Released on OpenRouter	Aug 14, 2026
Provider	AkashML (single)
Throughput	18 tok/s (P50)
Latency	1.50s (P50)
Uptime (3d)	91.97%
Availability (3d)	79.65%
Tool call error rate	1.06%
Structured output error rate	17.52%

Early production traffic tells the story: Qwen3.8-27B's top apps on OpenRouter are Kilo Code (7.98M tokens), Zed Editor (7.02M), pi (4.82M), and Hermes Agent (4.5M) — all agentic coding tools. At $0.45/$3.20, Qwen3.8-27B undercuts most frontier APIs by an order of magnitude while handling tool calls, structured outputs, images, and video.

For API usage, Qwen3.8-27B follows the standard Qwen3.8 pattern: thinking mode on by default (enable_thinking: True), reasoning_effort of xhigh/medium/low, and preserve_thinking: True by default. Recommended sampling: thinking mode at temperature 1.0 / top_p 0.95; instruct mode at 0.7 / 0.8 with presence_penalty 1.5.

⚠️ Attention: OpenRouter currently routes Qwen3.8-27B through a single provider (AkashML) with 79.65% availability over 3 days and a 17.52% structured-output error rate. For production reliability, wait for Qwen Cloud's hosted version or self-host.

Running Qwen3.8-27B Locally

This is where Qwen3.8-27B shines brightest — "RTX 3090 fans: ENGAGE" was the top comment on the release thread. Community reports:

Dual RTX 5080 (32GB total): user n0head_r ran the unsloth Qwen38-27B-Q6_K GGUF with 172K context (kv q8_0), MTP + tensor-split at a stable ~100 tps until 60–70K context (~95 tps at 100K). A 150K-token agent loop — writing, building, verifying, fixing errors — completed with zero failed tool calls.
RTX 4080 16GB: on r/ollama, Qwen3.8-27B ran at 12.6GB VRAM / 5.6GB CPU with an 8K context, completing a 2-tool agentic task (math eval + live crypto price, both correct) in ~18s.
RTX 3090 24GB: expected to be the sweet spot for Q4/Q6 quantizations, with Q8_0 also reported working via unsloth.

Deployment options for Qwen3.8-27B:

Hugging Face Transformers — AutoModelForMultimodalLM.from_pretrained("Qwen/Qwen3.8-27B")
vLLM / SGLang / TokenSpeed — vllm serve "Qwen/Qwen3.8-27B" for OpenAI-compatible serving
llama.cpp / Ollama / LM Studio — via the 319 community quantizations (Q4_K_M, Q6_K, Q8_0, etc.)
Docker Model Runner — docker model run hf.co/Qwen/Qwen3.8-27B

✅ Best Practice: If you're on a single 16–24GB GPU, grab a Q4 or Q6 GGUF of Qwen3.8-27B from unsloth; with 32GB+ VRAM or dual cards, Q8_0 with tensor splitting and MTP gives the best speed/quality balance.

Qwen3.8-27B vs the Competition

How does Qwen3.8-27B stack up against the models it's being compared to?

Model	Size	DeepSWE	Terminal Bench	Local-friendly	Vision
Qwen3.8-27B	27B dense	42.2	73.0	✅ (16GB+ VRAM)	✅ image+video
DeepSeek V4 Flash 0731	284B A13B	54.4	82.7	⚠️ (big)	❌
Qwen3.6-27B	27B dense	13.3	63.4	✅	✅
Opus 4.6 Max	frontier	–	78.2	❌	✅
Minimax M2.7	MoE	–	–	⚠️	❌

Reddit's read: "at 27B parameters, Qwen3.8-27B is pretty close to DeepSeek V4 Flash 0731 which is 284B A13B!" — while others noted "It seems better than 900+B MoE" and asked whether Qwen3.8-27B beats Minimax M2.7 in agentic coding. The verdict so far: Qwen3.8-27B offers frontier-adjacent agentic and multimodal performance at a fraction of the parameter count, and it's the strongest local coder candidate since the 27B class began.

🤔 FAQ: Qwen3.8-27B

Q: What is Qwen3.8-27B?

A: Qwen3.8-27B is Alibaba Qwen's 27-billion-parameter dense vision-language model, released as open weights under Apache 2.0 in August 2026. It understands images and videos, supports flexible thinking control, and targets coding, professional work, research, and long-horizon agentic tasks.

Q: How much does Qwen3.8-27B cost?

A: On OpenRouter, Qwen3.8-27B costs $0.45 per million input tokens and $3.20 per million output tokens. It's also free to self-host under Apache 2.0, and a Qwen Cloud hosted version with 1M context is coming soon.

Q: What is the context length of Qwen3.8-27B?

A: Qwen3.8-27B natively supports 262,144 tokens (262K), extensible to 1,000,000 tokens via YaRN RoPE scaling in vLLM, SGLang, or TokenSpeed.

Q: Does Qwen3.8-27B support images and video?

A: Yes. Qwen3.8-27B is a native vision-language model with image and video input — from STEM diagrams and documents to hour-scale videos — plus computer-use and browser-use capabilities (OSWorld-Verified 84.3, WebArena-Verified 64.8).

Q: Can I run Qwen3.8-27B locally?

A: Yes. Qwen3.8-27B runs on consumer GPUs: reported setups include RTX 3090 24GB, dual RTX 5080s (Q6_K at ~100 tps with 172K context), and RTX 4080 16GB (12.6GB VRAM via Ollama). 319 quantization variants are available.

Q: Does Qwen3.8-27B support tool calling and structured outputs?

A: Yes. Qwen3.8-27B supports tool calling, JSON output, and the OpenAI-compatible Chat Completions API, and it's already used in production by Kilo Code, Zed, pi, and Hermes Agent via OpenRouter.

Q: Is Qwen3.8-27B open source?

A: Qwen3.8-27B ships under the Apache 2.0 license — fully open weights, commercial use allowed. It's available on Hugging Face (Qwen/Qwen3.8-27B) and ModelScope.

Q: When was Qwen3.8-27B released?

A: Qwen3.8-27B was released on August 14, 2026 (open weights on Hugging Face and ModelScope, plus same-day availability on OpenRouter), following Qwen's announcement alongside Qwen3.8-Max.

Q: How does Qwen3.8-27B compare to Qwen3.6-27B?

A: Qwen3.8-27B roughly triples DeepSWE (13.3 → 42.2), gains ~10 points on Terminal Bench (63.4 → 73.0), +8.2 on SWE-bench Pro, and +20 on OSWorld (63.9 → 84.3) versus Qwen3.6-27B — a full generation's worth of progress.

Summary & Recommended Actions

Qwen3.8-27B is the model the local-AI community has been waiting for: frontier-adjacent agentic performance — DeepSWE 42.2, SWE-bench Pro 61.7, OSWorld 84.3, LiveCodeBench v6 90.3 — in a 27B dense package that runs on a single 24GB GPU, beats Opus 4.6 Max on multiple benchmarks, and costs $0.45/$3.20 per million tokens on OpenRouter. It has vision (image + video), flexible thinking control, 262K native context, and Apache 2.0 licensing.

The caveats: benchmarks are Qwen's own until independently verified, the single AkashML provider on OpenRouter has 79.65% availability, and structured-output reliability (17.52% error rate) needs watching. But as one commenter put it: "At this rate next year maybe we won't need AI-aaS companies."

Your next steps:

Try the API — test Qwen3.8-27B on OpenRouter for an agentic coding task and compare against your current model.
Download a GGUF — grab a Q4/Q6_K quantization of Qwen3.8-27B from unsloth and try it on your local GPU today.
Watch for Qwen Cloud — the hosted Qwen3.8-27B with 1M context and built-in tools is coming soon; keep an eye on Hugging Face for updates.

Sources: Qwen3.8-27B on Hugging Face · r/LocalLLaMA release thread · Qwen3.8-27B on OpenRouter · Qwen3.8-Max blog · r/ollama benchmarks · Medium: the most important local AI release of 2026

Originally published at: Qwen3.8-27B (2026): The Complete Guide to Qwen's New 27B Vision-Language Model

DeepSeek Harness Agent Loop 2026: Inside the Replaceable Plugin That Drives Every Turn

cz — Fri, 14 Aug 2026 11:26:37 +0000

DeepSeek Harness Agent Loop 2026: Inside the Replaceable Plugin That Drives Every Turn

🎯 Core Takeaways (TL;DR)

The DeepSeek Harness agent loop is itself a replaceable plugin: packages/core/agent-loop ships ReactLoopAgent as the default implementation of the Agent interface defined by core/agent — other plugins depend only on the interface, never on the loop, so the whole loop can be swapped out.
The DeepSeek Harness agent loop operates on two levels: a turn (zero or more steps, opened when the first input arrives and closed when the model owes nothing) and a step (one model request plus the tools it calls). Model-visible history is never stored separately — it is projected from the append-only session log via deriveMessages().
A phase state machine (idle | maintenance | running) gates the driver, and every boundary — turn/start, step/start, user/message, assistant/chunk, tool/call, tool/result, step/end, turn/end — is written to the durable session log, so fork, resume, replay, and telemetry all derive from one event stream.
Four extension points make the DeepSeek Harness agent loop interceptable without modification: agent/pre-step (waterfall), agent/request (waterfall), agent/request-error (waterfall), and agent/turn-stopping (serial). Tool execution runs through a three-stage pipeline: tools/pre-execute → tools/execute → tools/post-execute.
If you are building plugins for the DeepSeek Harness agent loop, the DSH Plugins directory is the place to discover, list, and share them with the ecosystem.

What Is the DeepSeek Harness Agent Loop?
Two Levels: Turns and Steps
The Phase State Machine
The Full Loop, Step by Step
Tool Execution: The Three-Stage Pipeline
Durable Events vs. Extension Points
Why a Replaceable Agent Loop Matters
The DSH Plugins Ecosystem
FAQ
Conclusion

What Is the DeepSeek Harness Agent Loop?

The DeepSeek Harness agent loop is the driver that keeps an agent working: it reads inputs, asks the model, executes tools, and decides when the agent owes the model another request. The defining fact about it — and the reason it deserves a deep dive — is that the loop itself is a plugin.

In packages/core/agent-loop, the default implementation is ReactLoopAgent, which implements the Agent interface defined by core/agent. Other plugins depend only on that interface, never on the concrete loop class. That single architectural decision means the DeepSeek Harness agent loop can be replaced wholesale: mount a different plugin that implements Agent, and every consumer keeps working. The interface is the contract; the loop is the implementation; the harness is the composition.

This is consistent with the broader "everything is a plugin" philosophy of DeepSeek Harness, which we covered in our earlier guide. The agent loop is not a privileged core component — it is one plugin among many, and it participates in the same event system as everything else.

💡 Professional Tip: When you read the code, start from the Agent interface in core/agent before reading ReactLoopAgent. Everything the loop does is a response to that contract, and the interface is what your own loop plugin must satisfy.

Two Levels: Turns and Steps

The DeepSeek Harness agent loop organizes work into two nested levels: turns and steps.

A turn is zero or more steps. It opens when the first input arrives and closes when the loop "no longer owes the model anything" — that is, when there is no pending input and no tool result that requires another model request.
A step is one model request plus the tools it calls. Each step is a single round trip through the model, followed by whatever tool calls the model requested.

The model-visible history is not stored separately. Instead, it is projected from the append-only session log by deriveMessages(). Everything the model can see must be reconstructible from the log — this is a hard invariant of the architecture, documented in docs/architecture.md. The practical consequence: the session log is the single source of truth, and the model's context window is always a derived view of it.

Level	Definition	Boundary Events
Turn	Zero or more steps; opened by first input, closed when the model owes nothing	`turn/start`, `turn/end`
Step	One model request + the tools it calls	`step/start`, `step/end`
Message	A user or assistant message within a step	`user/message`, `assistant/message`

The Phase State Machine

The driver of the DeepSeek Harness agent loop is gated by a small state machine: Phase = idle | maintenance | running.

idle — no driver is running; the agent is waiting for input.
maintenance — a transient state used while the driver is being torn down or prepared.
running — the driver is active across the entire drain interval, which can span multiple consecutive turns.

State transitions emit agent/status events, so any plugin can observe the loop's lifecycle without touching it. This is a recurring pattern in the DeepSeek Harness agent loop: state changes are events, and events are the extension surface.

The Full Loop, Step by Step

Here is the complete flow of the DeepSeek Harness agent loop, mapped to the actual code in packages/core/agent-loop/src/agent.ts.

Step 0: Wake and drive

Inputs enter through send, followup, steer, or inject, which push messages into the Inbox's two ordered queues (next-turn and next-step). followup and steer also wake the driver.

wakeDriver() — when idle, it claims a running phase (fresh AbortController, turn = previous turn, step = 0) and runs kick() inside ctx.agents.withInitiator(this, …).
kick() — while (await this.turn()) {}: as long as there is pending input, a new turn is opened.

Step 1: Open a turn

turn() first appends turn/start to the session — the durable open boundary. Then it loops over steps.

Step 2: Pre-step — claim input and interception decision

preStep() does three things:

inbox.claim(target, turn) — claims the input batch for this step (all next-step messages, plus one next-turn message at turn boundaries). Claiming is a pure splice-delete; each claimed message emits agent/inbox/claimed.
ctx.systemPrompt.assemble(...) — assembles the prompt sections and tool schema.
dispatch.waterfall('agent/pre-step', …) — the first extension point. Listeners can reject (no step opens; the turn ends as blocked) or enter and rewrite the message batch; the default enter uses the claimed messages. The result is { reject } or { enter, messages, assembly }.

💡 Special case: if the first step is rewritten to empty, the turn still occupies its boundary but does not spend a model call — it ends as completed.

Step 3: Open a step and persist user messages

session.append('step/start', { turn, step }) — durable.
Each message in decision.messages is appended as user/message — durable. Claimed inputs become durable user messages only at this point.

Step 4: Build the request, stream, assemble, call tools

step() runs an inner loop (which supports retries):

4a. Build the request — buildRequest():

dispatch.waterfall('agent/request', …) — the second extension point. Listeners can replace the frozen call configuration (provider, model, reasoningEffort, maxTokens); the default uses agent options or the recorded header.
ctx.llm.prepareCall(config, signal) — binds to the concrete adapter and materializes exact-model defaults.
session.append('request/header', …) and request/context (only when it changes) — durable, so the log can rebuild the request.
The frozen request is assembled: config + deriveMessages() history + system + tools + sessionId + signal.

4b. Stream:

preparedCall.stream(request) ?? ctx.llm.stream(request) — send the request and read the stream.
for await chunk — each chunk is appended as assistant/chunk (durable, preserving raw stream fidelity for replay and UI) and fed to the BlockAssembler.

4c. Finish dispatch — assembler.finish:

error / aborted → dispatch.waterfall('agent/request-error', …) — the third extension point. A listener returning { kind: 'retry' } (without calling next) retries the step; the default undefined lets the failure terminate (throwing LlmError).
max-tokens → append assistant/message, return { kind: 'max-tokens' }.
Normal → append assistant/message with { turn, step, message, usage } and sourceEventSeqs referencing the corresponding chunks — durable.

4d. Tool calls:

Filter tool-call blocks from the assistant message. None → return { kind: 'completed' } (the step ends; the model owes nothing).
Some → executeToolCalls(...) in tool-calls.ts.

Step 5: Close the step, decide whether to open another

finally: session.append('step/end', { turn, step }) — durable.
If the step produced a terminal result (turnEnds is non-null) and the inbox has no next-step input:
- dispatch.serial('agent/turn-stopping', { turn, signal }) — the fourth extension point (serial, no next). A listener that objects calls agent.steer(...) to inject steering; the machine re-reads the inbox and opens another step. If nobody objects, the turn closes.
If there is next-step input → target = 'next-step', back to step 2 for another step (tool continuation).

Step 6: Close the turn, decide whether to open another

finally: session.append('turn/end', { turn, reason: turnEnds }) — durable. reason is one of completed / max-tokens / blocked / aborted / error.
If the inbox still has pending input → reset the AbortController, step = 0, return true (open a new turn). Otherwise → back to idle.

Tool Execution: The Three-Stage Pipeline

Tool scheduling in the DeepSeek Harness agent loop groups calls by execution mode: mutually exclusive calls are a barrier, parallel calls use a bounded rolling pool (maxParallelToolCalls). Each call runs through a three-stage pipeline, with events mounted on the ctx.tools scheduler — the attachment point for policy, timeouts, and observability:

tools/pre-execute → tools/execute → tools/post-execute

prepare (pre-execute) may short-circuit into a direct result.
dispatch (execute) runs the tool.
finalize / finish (post-execute) wrap up.

Two details are worth calling out. First, results are committed in model order (commitReady advances across consecutive slots), not in completion order — the model's view of the world stays consistent. Second, tool/call is appended before dispatch (durable), and tool/result is appended after post-execute (durable, referencing the corresponding call seq). A result's additionalContexts go into the next-step inbox and become the context for the next step boundary; a result with concludesTurn ends the turn early.

The return value is { concluded }: concluded → { kind: 'completed' }; otherwise null is returned, meaning the tools still owe the model a request — back to 4a for another round.

Durable Events vs. Extension Points

The whole design of the DeepSeek Harness agent loop can be summarized in one diagram: durable events (the record) versus extension points (the seams).

turn/start (durable)
  claim inbox + assemble prompt
  ─ agent/pre-step (waterfall) reject | enter(messages) ─
  step/start (durable)
  user/message* (durable)
  ─ agent/request (waterfall) swap config ─
  llm/stream → assistant/chunk* (durable) → assistant/message (durable)
  tool/call* (durable) → tools/pre-execute → tools/execute → tools/post-execute → tool/result* (durable)
  ─ agent/request-error (waterfall) retry on failure ─
  step/end (durable)
  tools still owe a request or next-step input → open another step
  ─ agent/turn-stopping (serial) close turn unless continued ─
turn/end (durable)

Extension Point	Kind	What a Plugin Can Do
`agent/pre-step`	waterfall	Reject the step, or enter and rewrite the message batch
`agent/request`	waterfall	Replace the frozen call config (provider, model, effort, tokens)
`agent/request-error`	waterfall	Return `{ kind: 'retry' }` to retry the failed step
`agent/turn-stopping`	serial	Object by steering; the loop re-reads the inbox and opens another step

The lines marked ─ ─ are extension points where plugins can hook in (waterfalls must call next() to pass through). Everything else marked (durable) is a persisted event written to the session log — fork, resume, transcription, and telemetry all derive from this one stream. The meaning of the design: swapping an adapter, adding policy, or intercepting requests, tools, and turns is a matter of mounting events or replacing a provider — never of modifying the loop itself.

Why a Replaceable Agent Loop Matters

The DeepSeek Harness agent loop being a plugin is not an implementation detail; it is the product. Three consequences follow:

No fork required. Teams that need a different loop behavior — a different retry policy, a different tool-scheduling strategy, a different turn-closing heuristic — write a plugin that implements Agent, rather than maintaining a fork of the harness.
Policy lives at the seams. Timeouts, approval gates, rate limits, and observability attach to the ctx.tools scheduler and the four extension points, not inside the loop's code.
The log is the contract. Because every model-visible artifact is reconstructible from the append-only session log, any loop implementation — default or custom — can be audited, replayed, and resumed through the same tooling.

✅ Best Practice: Before writing a custom loop, check whether your need is actually a policy that can be mounted on an existing extension point. The DeepSeek Harness agent loop is designed so that most customizations never touch the loop at all.

The DSH Plugins Ecosystem

Because the DeepSeek Harness agent loop and every other capability are plugins, the ecosystem around them matters as much as the core. The DSH Plugins directory is the community hub for discovering and listing plugins for DeepSeek Harness — including loop replacements, tool adapters, model providers, and policy plugins. If you are building for the DeepSeek Harness agent loop, listing your plugin there makes it discoverable to the wider community, and browsing it before you build can save you from reinventing an existing plugin.

FAQ

Q: Is the DeepSeek Harness agent loop really a plugin?

A: Yes. packages/core/agent-loop ships ReactLoopAgent as the default implementation of the Agent interface from core/agent. Other plugins depend only on the interface, so the entire loop can be replaced by mounting a different plugin.

Q: What is the difference between a turn and a step in the DeepSeek Harness agent loop?

A: A turn is zero or more steps, opened when the first input arrives and closed when the model owes nothing. A step is one model request plus the tools it calls. Turns and steps both have durable start/end events in the session log.

Q: Where does the model's history come from?

A: It is not stored separately. The DeepSeek Harness agent loop projects the model-visible history from the append-only session log via deriveMessages(). Everything the model can see must be reconstructible from the log.

Q: What extension points does the DeepSeek Harness agent loop expose?

A: Four: agent/pre-step (waterfall — reject or rewrite the input batch), agent/request (waterfall — replace the call config), agent/request-error (waterfall — retry on failure), and agent/turn-stopping (serial — object to closing the turn by steering).

Q: How are tool results ordered?

A: Results are committed in model order (commitReady advances across consecutive slots), not in completion order, so the model's view of the world stays consistent.

Q: Where can I find plugins for the DeepSeek Harness agent loop?

A: The DSH Plugins directory lists community plugins for DeepSeek Harness, including loop replacements, tool adapters, and policy plugins.

Conclusion

The DeepSeek Harness agent loop is a masterclass in replaceable architecture. By defining an Agent interface, shipping ReactLoopAgent as one implementation among many, persisting every boundary to an append-only log, and exposing four waterfall/serial extension points, the loop turns what is usually the most rigid part of an agent harness into the most flexible one.

The practical takeaway for developers: you do not need to understand the loop to use it, but understanding it unlocks the seams. Intercept a request at agent/request, retry a failure at agent/request-error, gate a turn at agent/turn-stopping, or replace the whole loop with your own Agent implementation. And when you build something worth sharing, the DSH Plugins directory is where the ecosystem finds it. The loop is the heart of DeepSeek Harness — and it is a heart you can transplant.

Originally published at: DeepSeek Harness Agent Loop 2026: Inside the Replaceable Plugin That Drives Every Turn

DeepSeek Harness 2026: Everything Is a Plugin — Developer Preview Guide

cz — Thu, 13 Aug 2026 13:24:49 +0000

DeepSeek Harness 2026: Everything Is a Plugin — Developer Preview Guide

🎯 Core Takeaways (TL;DR)

DeepSeek Harness (CLI name dsh) opened its v0.1 developer preview to the global harness developer community on August 13, 2026, with the full source released under the MIT license on GitHub.
The defining design principle of DeepSeek Harness is "everything is a plugin": models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and UI are all Cordis plugins that can be freely swapped, replaced, and recombined — no source changes required.
DeepSeek Harness ships four run modes — Standard, PTC (Programmatic Tool Calling), Minimal, and Creation — each loading a different default plugin set for a different use case.
Every run of DeepSeek Harness is fully traceable: everything the model sees is written to an append-only session log, viewable by source in the Trajectory view, with resume, fork, retrieval, and replay all sharing the same event stream.
You can try DeepSeek Harness in under a minute: npx @deepseek-ai/dsh web starts the Web UI at http://127.0.0.1:3080.

What Is DeepSeek Harness?
The "Everything Is a Plugin" Philosophy
Four Run Modes of DeepSeek Harness
Append-Only Session Logs and the Trajectory View
Architecture: Profiles, Bundles, and Core Packages
How to Get Started with DeepSeek Harness
Building Plugins for DeepSeek Harness
DeepSeek Harness vs. Other Agent Harnesses
FAQ
Conclusion

What Is DeepSeek Harness?

DeepSeek Harness is an open-source agent harness developed by DeepSeek AI. It is the infrastructure layer that sits between a large language model and the tools, files, and environments an agent needs to get work done. Where many harnesses hard-code their components, DeepSeek Harness takes a radically different approach: every capability is a plugin, and the harness itself is just a composition of plugins.

On August 13, 2026, the DeepSeek Harness team announced the v0.1 developer preview, opening testing to harness developers worldwide and releasing the source code under the MIT license. The announcement, published on the team's official WeChat channel, was explicit that v0.1 is an early preview: many details are still being polished, and core plugins and base interfaces will iterate quickly in the coming releases. The team is inviting feedback from the global harness developer community as it builds out the DSH plugin ecosystem.

The project lives at github.com/deepseek-ai/deepseek-harness, is powered by the Cordis plugin framework, and is currently at version 0.1.0-rc.5 in its repository. The monorepo is organized into apps/ (the cli and web applications) and packages/ (core, llm, mcp, sandbox, context, plan, goal, and dozens more), which gives you a sense of the breadth of capabilities DeepSeek Harness composes out of the box.

💡 Professional Tip: Because DeepSeek Harness is in developer preview, expect compatibility-breaking changes. Pin the version you build against, and follow the GitHub repository for release notes before upgrading.

The "Everything Is a Plugin" Philosophy

The single most important idea in DeepSeek Harness is stated in its own documentation: everything is a plugin. The architecture is built on the Cordis plugin system, which is designed for spatiotemporal composability — a programming paradigm described in the Cordis paper, A Programming Paradigm for Spatiotemporal Composability.

Cordis acts as a meta-framework: it is responsible only for loading and unloading plugins and managing their dependencies. Every concrete component of DeepSeek Harness — the model adapter, the tool registry, the session log, the agent loop itself — is a different Cordis plugin. Plugins cooperate through Cordis services and typed events, and they can be freely combined at the configuration layer.

What this means in practice is that developers do not need to modify the source code of DeepSeek Harness to independently select, replace, or extend any of its capabilities. If you want a different model provider, you swap the model plugin. If you want a different sandbox, you swap the sandbox plugin. If you want a completely different agent loop, you mount your own. There is no privileged core to patch — you extend DeepSeek Harness by mounting a plugin beside the others, and registrations are effects that unwind cleanly when their plugin unloads.

✅ Best Practice: Treat every capability of DeepSeek Harness as replaceable. Before writing custom code, check whether a plugin already exists — the ecosystem is designed so that composition beats modification.

Four Run Modes of DeepSeek Harness

For different usage scenarios, DeepSeek Harness provides four modes, each of which loads a different default set of plugins:

Mode	What It Loads	Best For
Standard	A complete tool set	Everyday agentic work
PTC	Programmatic Tool Calling — the model generates one piece of code that composes multiple tool calls	Complex multi-step tool workflows
Minimal	Only one shell tool and one file-edit tool	Model benchmarking in minimal environments
Creation	Inspect the current runtime, experiment with Cordis plugins in memory, and compose new modes	Building and testing new plugin combinations

The PTC mode deserves special attention. Programmatic Tool Calling is a distinctive design in DeepSeek Harness: instead of the model making many individual tool calls, the model generates a single piece of code that orchestrates multiple tool calls in sequence. This reduces round trips, improves reliability, and gives the model a more expressive way to compose tools.

The Creation mode is equally interesting for plugin developers. It lets you inspect the running runtime, experiment with Cordis plugins in memory, and compose and create new modes from what you learn — a sandbox for designing the next configuration of DeepSeek Harness without restarting anything.

Append-Only Session Logs and the Trajectory View

One of the most developer-friendly features of DeepSeek Harness is its observability story. Every run is traceable: everything the model sees is written to an append-only session log, including system prompts, chain-of-thought, tool calls and their results, sub-agent scheduling, and every context injection.

In the Trajectory view, you can inspect all of this information by source. Because the log is append-only, nothing is ever silently rewritten — the record of what happened is preserved exactly as it occurred. Resume, fork, retrieval, and replay all share the same event stream, which means you can pick up a session where it left off, branch it into a new direction, search through its history, or replay it to understand what happened.

This design has practical consequences for debugging. When an agent run goes wrong, the session log of DeepSeek Harness shows you precisely what the model saw at every step — the exact system prompt, the exact tool output, the exact context injection. For teams building production agents, this level of traceability is the difference between guessing and knowing.

Architecture: Profiles, Bundles, and Core Packages

Under the hood, a running DeepSeek Harness is a plugin tree composed at boot from ordered layers. Two concepts organize this tree: profiles and bundles.

A profile is a named composition stored in the Harness home directory. It lists the bundles it stacks, holds any out-of-tree plugins it installs, and keeps the user's own cordis.patch.yml. The web and headless profiles ship as templates. A bundle is a distribution format for Cordis config rows and the code they mount, so whatever a bundle inserts stays patchable by the layers above it.

The base layer of every profile is dsh-base, which provides model adapters, tools, persistence, sandbox and approval policy, settings, credentials, and telemetry. dsh-web-app adds the browser application, and dsh-headless adds a one-shot runner with no server at all. You can inspect the exact tree your machine boots with:

dsh --profile web --dump-config

Any row printed by that command can be replaced by a patch of your own. The core packages of DeepSeek Harness map cleanly to responsibilities:

Package	Owns	`ctx` key
`core/session`	The append-only `SessionEvent` log and in-memory store	`ctx.sessions`
`core/system-prompt`	Prompt-section and tool-schema assembly	`ctx.systemPrompt`
`core/tools`	The scoped tool registry and guarded execution pipeline	`ctx.tools`
`core/agent`	The `Agent` interface, live registry, and `agent/*` events	`ctx.agents`
`core/agent-loop`	The default driver implementing that interface	`ctx.agentLoop`
`core/scope`	The per-agent scoped-registration primitive	library, no key

How to Get Started with DeepSeek Harness

Getting started with DeepSeek Harness takes minutes. The quickest path is the Web UI:

npx @deepseek-ai/dsh web

This command starts the Web UI, served at http://127.0.0.1:3080 by default. From there, the workflow is straightforward:

Configure a model: open Settings → Models, enter a DeepSeek API key, and save it. The model route becomes usable immediately without restarting the server. Other providers and custom OpenAI-compatible endpoints are supported via the model configuration guide.
Choose a workspace: click Choose workspace, add the project directory where you started dsh, and select it. The session composer stays unavailable until a workspace is selected.
Run a task: start a session and send a prompt. The agent can read and edit workspace files, run commands, delegate work, and maintain a plan. The Web UI asks before operations that require approval under the active permission policy.

If you prefer to run from source:

git clone https://github.com/deepseek-ai/deepseek-harness
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web

The dsh process uses its invoking directory as the default filesystem location, and a fresh Web UI has no selected workspace until you add one. For headless automation, DeepSeek Harness also ships a one-shot runner profile with no server at all, plus a Python SDK for programmatic use.

⚠️ Attention: The dsh Web UI asks for approval before operations that require it under the active permission policy. Configure your permission policy deliberately before running untrusted tasks.

Building Plugins for DeepSeek Harness

Because everything in DeepSeek Harness is a plugin, plugin development is the primary extension path. The architecture documentation recommends starting with the Cordis primer and tutorial before writing plugins, since the framework's model of services, typed events, and reversible effects is the foundation of the whole system.

A plugin in DeepSeek Harness contributes services, typed events, and reversible effects to a shared context. When a plugin unloads, its registrations unwind — there is no orphaned state. Plugins are distributed as bundles, declared in package.json under a dsh field: dsh.profile lists a profile's bundles, and dsh.bundle points at a bundle's patch file.

The practical workflow for plugin authors is: experiment in Creation mode, where you can inspect the runtime and test Cordis plugins in memory; then package your plugin as a bundle; then mount it in a profile, either by editing cordis.patch.yml or by passing a --patch overlay. The --dump-config command shows you the exact rows your machine boots, so you always know what to patch.

The DeepSeek Harness team is explicitly courting the plugin ecosystem: the announcement invites global harness developers to co-build the DSH plugin ecosystem on open, reusable, composable infrastructure. If you build a plugin, you can add the dsh-plugin topic to your repository for discoverability.

DeepSeek Harness vs. Other Agent Harnesses

How does DeepSeek Harness compare to the agent harnesses most developers already know? The differences are mostly architectural:

Dimension	DeepSeek Harness	Typical Harness
Architecture	Everything is a plugin (Cordis)	Monolithic core + extensions
Extension path	Mount a plugin, no source changes	Fork or patch the core
Observability	Append-only session log + Trajectory view	Varies, often partial
Run modes	Standard / PTC / Minimal / Creation	Usually one mode
License	MIT, open source	Varies
Tool calling	Classic + PTC (code-composed calls)	Usually classic only

The most consequential difference is the plugin seam. In DeepSeek Harness, there is no privileged core to patch — every component, including the agent loop itself, is replaceable from configuration. For teams that have hit the limits of a harness's extension points, that is a meaningful difference. The append-only session log is also ahead of most alternatives, which typically log tool calls but not every context injection.

FAQ

Q: Is DeepSeek Harness free and open source?

A: Yes. DeepSeek Harness is released under the MIT license, and the full source is available at github.com/deepseek-ai/deepseek-harness. The v0.1 developer preview opened to the global community on August 13, 2026.

Q: How do I start DeepSeek Harness quickly?

A: Run npx @deepseek-ai/dsh web in a terminal with Node.js installed. The Web UI starts at http://127.0.0.1:3080. Then add a model API key in Settings → Models and choose a workspace.

Q: What does "everything is a plugin" mean in practice?

A: It means every capability of DeepSeek Harness — models, tools, skills, sessions, sandboxes, storage, loops, scheduling, UI — is a Cordis plugin. You can select, replace, or extend any of them without modifying the source code of DeepSeek Harness itself.

Q: What are the four modes of DeepSeek Harness?

A: Standard (complete tool set), PTC (programmatic tool calling, where the model writes code to compose tool calls), Minimal (one shell tool and one file-edit tool for benchmarking), and Creation (inspect the runtime and compose new modes in memory).

Q: Can I use DeepSeek Harness with models other than DeepSeek's?

A: Yes. The model configuration guide covers other providers and custom OpenAI-compatible endpoints. The model adapter is itself a plugin, so it is replaceable by design.

Q: Is DeepSeek Harness production-ready?

A: Not yet. v0.1 is an early developer preview with compatibility-breaking changes expected. It is ideal for experimentation, benchmarking, and plugin development, but teams should pin versions and follow the repository before relying on it in production.

Conclusion

DeepSeek Harness enters the agent infrastructure landscape with a bold bet: that the right architecture for agent harnesses is one where everything is a plugin. By building on Cordis, releasing under MIT, and shipping four run modes plus an append-only session log, the DeepSeek Harness team has given developers a harness that is open, observable, and composable to its core.

The v0.1 developer preview is explicitly a starting point, not a finish line. The team is inviting global harness developers to co-build the DSH plugin ecosystem on open, reusable, composable infrastructure, and the plugin-first design makes that invitation concrete: anyone can mount a plugin beside the others, no fork required.

If you build agents, the practical next step is simple. Clone the repository, run npx @deepseek-ai/dsh web, and spend an hour in Creation mode experimenting with plugins. Whether DeepSeek Harness becomes your production harness or just informs how you think about harness architecture, the everything-is-a-plugin design is worth studying — and it is now open for everyone to explore.

Originally published at: DeepSeek Harness 2026: Everything Is a Plugin — Developer Preview Guide

awesome design md (2026): The Complete Guide to Google's DESIGN.md Collection

cz — Thu, 13 Aug 2026 09:26:25 +0000

awesome design md (2026): The Complete Guide to Google's DESIGN.md Collection

🎯 Core Takeaways (TL;DR)

awesome design md is the fastest-growing community collection of DESIGN.md files on GitHub — VoltAgent's repository has surpassed 108,000 stars and ranks #105 globally on GitHub as of August 2026.
It ships 73 ready-to-use DESIGN.md files extracted from real websites like Stripe, Vercel, Linear, Figma, Tesla, and Spotify — drop one into your project, tell your AI agent "build me a page that looks like this," and get visually consistent UI.
Every entry in the awesome design md collection includes a full DESIGN.md plus preview.html and preview-dark.html, covering 9 sections from color tokens and typography to component states and responsive behavior.
awesome design md is built on the DESIGN.md standard that Google Stitch introduced and Google Labs open-sourced as a draft specification on April 21, 2026 — a plain-text markdown file that AI agents read to generate consistent UI.

What Is awesome design md?
What Is DESIGN.md and Why Does It Matter?
What's Inside the awesome design md Collection
How to Use awesome design md with AI Agents
Top Design Systems in awesome design md
How awesome design md Compares to Alternatives
FAQ

What Is awesome design md?

awesome design md is a curated GitHub repository by VoltAgent that collects DESIGN.md files analyzed from developer-focused websites. Its tagline is simple: copy a DESIGN.md into your project, tell your AI agent "build me a page that looks like this," and generate high-quality UI that stays visually consistent with the design language.

The repository — github.com/voltagent/awesome-design-md — describes itself as a "curated collection of DESIGN.md analysis by developer focused websites." Since launching in March 2026, awesome design md has grown to 108,000+ stars and a global GitHub rank of #105, making it one of the most-starred AI tooling repos of the year. It carries the official Awesome badge, a Discord community, and a sponsorship channel.

Why did awesome design md explode so fast? Because it fills a real gap: AI coding agents are great at writing code but bad at guessing your design language. awesome design md hands them the design system in the one format they read best — plain markdown.

💡 Professional Tip: The repo is MIT-licensed and every DESIGN.md inside is provided "as is" for generating consistent UI. The design tokens represent publicly visible CSS values — VoltAgent doesn't claim ownership of any brand's visual identity, so you can safely drop them into personal and commercial projects.

What Is DESIGN.md and Why Does It Matter?

To understand awesome design md, you first need to understand DESIGN.md. DESIGN.md is a new concept introduced by Google Stitch — a plain-text design system document that AI agents read to generate consistent UI. It's just a markdown file: no Figma exports, no JSON schemas, no special tooling. Drop it into your project root, and any AI coding agent or Google Stitch instantly understands how your UI should look.

The mental model pairs it with the AGENTS.md convention:

File	Who reads it	What it defines
`AGENTS.md`	Coding agents	How to build the project
`DESIGN.md`	Design agents	How the project should look and feel

On April 21, 2026, Google Labs open-sourced the draft specification of DESIGN.md, and the standard went mainstream — within days, the official spec repo crossed 10,000 stars while awesome design md surged past 68,000. Today awesome design md is widely cited — including in design tutorials from banani.co and design-bootcamp — as the single most popular resource for ready-made DESIGN.md files.

That's the entire point of awesome design md: instead of writing a design system from scratch, you borrow one that has already been extracted, analyzed, and structured by a team that cares about quality.

What's Inside the awesome design md Collection

awesome design md currently hosts 73 DESIGN.md files organized into 9 categories. Each entry follows the Stitch DESIGN.md format with extended sections:

#	Section	What it captures
1	Visual Theme & Atmosphere	Mood, density, design philosophy
2	Color Palette & Roles	Semantic name + hex + functional role
3	Typography Rules	Font families, full hierarchy table
4	Component Stylings	Buttons, cards, inputs, navigation with states
5	Layout Principles	Spacing scale, grid, whitespace philosophy
6	Depth & Elevation	Shadow system, surface hierarchy
7	Do's and Don'ts	Design guardrails and anti-patterns
8	Responsive Behavior	Breakpoints, touch targets, collapsing strategy
9	Agent Prompt Guide	Quick color reference, ready-to-use prompts

Each site in awesome design md ships three files:

File	Purpose
`DESIGN.md`	The design system (what agents read)
`preview.html`	Visual catalog: color swatches, type scale, buttons, cards
`preview-dark.html`	Same catalog with dark surfaces

The categories inside awesome design md span the full spectrum of modern web design: AI & LLM Platforms (Claude, Ollama, Mistral, xAI), Developer Tools & IDEs (Cursor, Vercel, Raycast, Warp), Backend & DevOps (Supabase, MongoDB, Sentry), Productivity & SaaS (Linear, Notion, Cal.com), Design & Creative (Figma, Framer, Webflow), Fintech & Crypto (Stripe, Coinbase, Binance), E-commerce (Shopify, Nike, Airbnb), Media & Consumer Tech (Apple, NVIDIA, Spotify), and even Automotive (Tesla, Ferrari, Bugatti).

awesome design md also has a delightfully quirky series: Retro Web · DESIGN.md Nostalgia. A Saturday series with period-accurate vintage UI — like Dell (1996) with "hand-cut GIF stickers" and Nintendo.com (2001) with "brushed-periwinkle beveled metal panels" — so you can tell your agent to build a time-capsule webpage.

✅ Best Practice: Not sure where to start with awesome design md? Pick a brand whose aesthetic you already admire — Vercel for black-and-white precision, Linear for ultra-minimal purple-accented UI, or Stripe for signature purple gradients. The design language you ship is the design language you live in.

How to Use awesome design md with AI Agents

Using awesome design md takes about two minutes:

graph TD
A[Browse awesome design md<br/>pick a site] --> B[Copy DESIGN.md<br/>into project root]
B --> C[Tell your AI agent<br/>'build a page like this']
C --> D[Agent reads tokens<br/>colors, type, components]
D --> E[Generate UI that matches<br/>the design language]

Browse the collection — open github.com/voltagent/awesome-design-md and pick a design system from the list (each links to a getdesign.md/<brand>/design-md page).
Copy the DESIGN.md into your project root, next to your AGENTS.md.
Prompt your agent — say "build me a landing page that matches the design in DESIGN.md," and Claude Code, OpenCode, Cursor, or any modern coding agent will follow the tokens and rules.
Iterate — use the Do's and Don'ts section of awesome design md files as guardrails, and check preview.html to see expected colors and type at a glance.

Community tutorials (including a popular YouTube walkthrough pairing awesome design md with OpenCode and Claude) confirm the workflow "is SO EASY & SO GOOD" — the hardest part is choosing which brand's aesthetic you want.

💡 Professional Tip: awesome design md maintainers accept requests at getdesign.md/request — you can request a DESIGN.md for a specific website, including private requests delivered exclusively to you. If your favorite brand isn't in the collection yet, that's the fastest way to fix it.

Top Design Systems in awesome design md

Here's a taste of what's inside awesome design md right now:

Brand	Category	Design language captured
Vercel	Dev tools	Black and white precision, Geist font
Linear	SaaS	Ultra-minimal, precise, purple accent
Stripe	Fintech	Signature purple gradients, weight-300 elegance
Claude	AI platforms	Warm terracotta accent, clean editorial layout
Figma	Design tools	Vibrant multi-color, playful yet professional
Supabase	Backend	Dark emerald theme, code-first
Shopify	E-commerce	Dark-first cinematic, neon green accent
Tesla	Automotive	Radical subtraction, cinematic photography
Spotify	Media	Vibrant green on dark, album-art-driven
Nintendo (2001)	Retro	Y2K console chrome, halftone-dotted carbon nav

Each of these entries took real work to produce — awesome design md isn't a list of links, it's a collection of deep design analysis. The repo's own description emphasizes "real design depth — including analyzed patterns, tokens, and rules — for high-quality UI generation, not surface-level outputs."

How awesome design md Compares to Alternatives

If you're evaluating awesome design md against the alternatives, here's the honest comparison:

Aspect	awesome design md	Write your own DESIGN.md	Design tokens from Figma
Time to first UI	Minutes	Hours to days	Requires tooling/exports
Depth of analysis	9 sections per file	Depends on your effort	Design tokens only, no rules
Brand aesthetics	73 real brands	Your own	Your own
Cost	Free (MIT)	Your time	Figma subscription
Agent readiness	Built for LLMs	Built for LLMs	Needs conversion

The gap awesome design md fills is the "starting point": it gives you a production-quality design system instantly, with previews, and lets you adapt it later. As one design-bootcamp analysis put it, "Google makes DESIGN.md open source on its way to becoming an industry standard" — and awesome design md is the community's biggest bet on that standard.

⚠️ Attention: DESIGN.md files in awesome design md replicate publicly visible CSS values of real brands. If you copy a brand's exact look for a client product, consider mixing palettes or renaming tokens so you build on the patterns rather than clone the brand.

🤔 FAQ: awesome design md

Q: What is awesome design md?

A: awesome design md is a GitHub repository by VoltAgent that curates DESIGN.md files extracted from 73 real websites — including Stripe, Vercel, Linear, Figma, and Tesla — so you can drop one into your project and have AI agents generate matching UI. It has over 108,000 stars.

Q: Where can I find awesome design md?

A: awesome design md lives at github.com/voltagent/awesome-design-md. Individual DESIGN.md files are hosted at getdesign.md (e.g., getdesign.md/stripe/design-md).

Q: Is awesome design md free to use?

A: Yes. awesome design md is MIT-licensed, and each included DESIGN.md is provided "as is" without warranty. You can use the files commercially, though the maintainers note the design tokens represent publicly visible CSS values and they don't claim ownership of any brand's identity.

Q: What is DESIGN.md?

A: DESIGN.md is a plain-text design system document introduced by Google Stitch and open-sourced as a draft specification by Google Labs on April 21, 2026. It's a markdown file that defines colors, typography, components, layout, and rules so AI agents can generate visually consistent UI. awesome design md is the biggest community collection of such files.

Q: How many DESIGN.md files are in awesome design md?

A: awesome design md currently contains 73 DESIGN.md files across 9 categories — from AI platforms and developer tools to fintech, e-commerce, automotive, and a retro 1990s series.

Q: What does each file in awesome design md include?

A: Each entry in awesome design md includes a DESIGN.md (design system with 9 sections: theme, colors, typography, components, layout, elevation, do's and don'ts, responsive behavior, and agent prompt guide) plus preview.html and preview-dark.html visual catalogs.

Q: How do I use awesome design md with my AI agent?

A: Copy a DESIGN.md from awesome design md into your project root, then prompt your agent with something like "build me a page that looks like this." Agents like Claude Code, Cursor, and OpenCode read the markdown directly — no conversion or tooling needed.

Q: Can I request a new DESIGN.md?

A: Yes — the awesome design md team accepts requests at getdesign.md/request, including private requests delivered exclusively to you. You can also contribute improvements via pull requests after opening an issue.

Summary & Recommended Actions

awesome design md is the rare GitHub phenomenon that arrived at exactly the right moment: DESIGN.md went from a Google Stitch experiment to an open industry standard in April 2026, and awesome design md became the community's default library for it — 108K stars, 73 design systems, and a global rank of #105.

If you build UI with AI agents, awesome design md is the fastest way to go from blank page to polished, design-consistent interface. It's free, MIT-licensed, deeply analyzed, and actively maintained.

Your next steps:

Star the repo — follow github.com/voltagent/awesome-design-md to track updates and new additions.
Try one today — copy the Vercel or Linear DESIGN.md into a scratch project and ask your agent to build a landing page; you'll see the difference within minutes.
Contribute or request — found a wrong color or missing token? Open an issue or PR. Need a brand that's not there? Use the getdesign.md request form.

Sources: awesome design md on GitHub · Google Stitch DESIGN.md overview · Google Labs: DESIGN.md format open-sourced · Google: Design UI using AI with Stitch · Star History for awesome design md · Banani: What Is Design.md and How to Use It · Medium: Google Makes DESIGN.md Open Source

Originally published at: awesome design md (2026): The Complete Guide to Google's DESIGN.md Collection

DeepSeek V4 Pro 0813 (2026): Complete Guide to Pricing, Benchmarks & How It Stacks Up Against Fable 5

cz — Thu, 13 Aug 2026 00:30:30 +0000

DeepSeek V4 Pro 0813 (2026): Complete Guide to Pricing, Benchmarks & How It Stacks Up Against Fable 5

🎯 Core Takeaways (TL;DR)

DeepSeek V4 Pro 0813 is the general-availability (GA) release of DeepSeek's 1.6T-parameter MoE flagship, live on August 12, 2026 — the official deepseek-v4-pro API endpoint now points to this build.
The headline story is agentic coding: DeepSWE jumped from 12.8 to 62.7, CyberGym from 52.7 to 83.3, and Terminal Bench 2.1 from 72.1 to 87.9 versus the preview — near Fable 5 territory at roughly 1/60th of the price.
Pricing is $0.435 per million input tokens (cache miss), $0.003625 (cache hit), and $0.87 per million output tokens, with a 1M-token context window — though DeepSeek has announced a significant price increase is coming.
DeepSeek V4 Pro 0813 has no vision support, a quirk that split the community — some see it as a dealbreaker, others as a reasonable trade for frontier-adjacent performance at budget pricing.

What Is DeepSeek V4 Pro 0813?
DeepSeek V4 Pro 0813 Pricing Breakdown
Benchmarks: The Big Agentic Gains
DeepSeek V4 Pro 0813 vs Fable 5 vs Opus 4.8
Real-World Feedback: What Early Users Report
How to Access DeepSeek V4 Pro 0813
FAQ

What Is DeepSeek V4 Pro 0813?

DeepSeek V4 Pro 0813 is the general-availability build of DeepSeek V4 Pro, DeepSeek's large-scale mixture-of-experts (MoE) model. The "0813" suffix marks the August 13 build identifier that closed out a preview period stretching back to the V4 family's open-weight debut on April 24, 2026.

Under the hood, DeepSeek V4 Pro 0813 is a massive model: 1.6 trillion total parameters with roughly 49 billion active per token, pretrained on more than 32 trillion tokens. It uses a hybrid attention system designed to cut inference costs at long context lengths — which matters, because the model supports a 1,048,576-token (1M) context window and up to 384,000 output tokens.

The release was staged deliberately. The smaller DeepSeek V4 Flash graduated to official status first on July 31, 2026, with DeepSeek's changelog promising the Pro release "will follow soon." That promise materialized on August 12, when the deepseek-v4-pro endpoint on DeepSeek's official API silently began pointing at DeepSeek V4 Pro 0813. Notably, as Simon Willison pointed out on Hacker News, DeepSeek shipped this upgrade without a blog post or even a tweet — the only announcement was the API documentation update itself.

💡 Professional Tip: Because DeepSeek V4 Pro 0813 shipped without an official announcement page, the most reliable places to track it are the DeepSeek API pricing page and its OpenRouter model page.

DeepSeek V4 Pro 0813 Pricing Breakdown

For an open-weight model of this size, DeepSeek V4 Pro 0813 is priced aggressively:

Pricing Metric	DeepSeek V4 Pro 0813	DeepSeek V4 Flash 0731
Input (cache miss) / 1M tokens	$0.435	$0.14
Input (cache hit) / 1M tokens	$0.003625	$0.0028
Output / 1M tokens	$0.87	$0.28
Context window	1M	1M
Max output	384K	384K
Concurrency limit	500	2,500

The cache-hit price is the sleeper stat. On OpenRouter, the measured cache hit rate for DeepSeek V4 Pro 0813 averages 88.9–92.17%, which drags the weighted-average input price customers actually pay down to about $0.051 per million tokens — roughly 1/8 of the listed rate. One HN user ran a heavy agentic workload (traffic simulator and distributed physics engine) all day for about $12.50, and commenters noted that with a properly configured harness pushing cache hits toward 99%, the same workload would cost a few dollars.

Two caveats worth knowing before you build on DeepSeek V4 Pro 0813:

⚠️ Attention: DeepSeek's official pricing page states it "plans to raise the overall pricing for DeepSeek API services in the near future, with a significant increase expected." Budget accordingly.

⚠️ Attention: Until more providers come online, OpenRouter routes DeepSeek V4 Pro 0813 directly through DeepSeek's official API, which may log and train on your prompts. Check DeepSeek's data policies before sending sensitive code.

Benchmarks: The Big Agentic Gains

The reason DeepSeek V4 Pro 0813 dominated Hacker News and r/LocalLLaMA on release day is the sheer size of the post-training jump. DeepSeek's official numbers (shared via its WeChat group and reposted by OpenRouter) show gains that would normally take a full model generation:

Benchmark	V4 Pro 0813	V4 Pro Preview	Gain
DeepSWE	62.7	12.8	+49.9
CyberGym	83.3	52.7	+30.6
NL2Repo	61.5	38.5	+23.0
Terminal Bench 2.1	87.9	72.1	+15.8
Toolathlon-Verified	74.1	55.9	+18.2
AutomationBench (Public)	31.8	12.8	+19.0
DSBench-FullStack	71.1	41.8	+29.3
DSBench-Hard	67.2	31.1	+36.1

The DeepSWE number deserves a double take. Across two releases, DeepSeek's engineering benchmark score went 7.3 → 12.8 → 62.7. As one Redditor put it: "The jump on DeepSWE is probably the most interesting number here. 7.3 → 62.7 in two releases is kind of wild 😅". DeepSeek attributes these gains entirely to improved post-training — the architecture of DeepSeek V4 Pro 0813 is unchanged from the preview.

DeepSeek V4 Pro 0813 vs Fable 5 vs Opus 4.8

The comparison that set the community buzzing: DeepSeek V4 Pro 0813 lands within a few points of Anthropic's frontier models on agentic benchmarks, at a fraction of the cost.

Benchmark	DeepSeek V4 Pro 0813	Opus 4.8	Fable 5 (w/ fallback)	Kimi K3	GLM-5.2
Terminal Bench 2.1	87.9	85.0	88.0	88.3	81.0
Cybergym	83.3	78.3	83.1	80.0	–
DeepSWE	62.7	58.0	70.0	67.5	46.2
Toolathlon-Verified	74.1	76.2	77.9	76.5	59.9
HLE (with tools)	60.0	57.9	63.0	56.0	54.7
AutomationBench (Public)	31.8	27.2	29.1	30.8	12.9
DSBench-Hard	67.2	71.7	68.3	63.0	54.5

One HN user computed geometric means across these suites: GPT-5.6 Sol leads at 65.5, Fable 5 at 64.5, Opus 5 at 64.0 — and DeepSeek V4 Pro 0813 at 62.5, ahead of Kimi K3's 62.3. That puts a $0.435/$0.87 model inside ~2 points of the most expensive models on the market. As r/LocalLLaMA commenters put it: "Close to Fable, nice. Comparing the pricing — nicer." and "this model is $0.87 per million tokens folks... basically 1/60th of Fable's cost."

✅ Best Practice: If your workload is text-only agentic coding, DeepSeek V4 Pro 0813 is the value play. If you need multimodal input, situational awareness for safety-sensitive reasoning, or maximum single-task reliability, a frontier model like Fable 5 or Opus still justifies its premium.

Real-World Feedback: What Early Users Report

Vibes on DeepSeek V4 Pro 0813 are mostly positive, with two recurring criticisms:

The wins:

A traffic-simulator workload found "some pretty significant gains without introducing any new problems" (~$12.50 for 2B tokens at 50% cache hits).
Simon Willison's SVG-rendering tests showed distinct, coherent "styles" at low/medium/high reasoning efforts — "almost like 3 models in one," as one commenter observed.
Local-hosting enthusiasts report you can self-host the open weights on a >128GB VRAM + 768GB RAM rig built from used P40s for roughly $3–3.5K.

The criticisms:

One HN test on Codex CLI: DeepSeek V4 Pro 0813 took 12m02s and $0.12 to add a feature but shipped with a bug, while Grok 4.6 took 3m18s and $1.41 with no bug. n=1, but it matches the general pattern: cheaper and slower, usually good enough.
Chinese developer karminski3 reported that with reasoning_effort=max on long-horizon agentic coding, the model tends to stop early: in a 50-round optimization loop, 2 of 3 runs halted around round 42–43 without using all available attempts, and it didn't beat GLM-5.1 in that setup. If you run long autonomous loops on DeepSeek V4 Pro 0813, monitor for premature termination.
No vision. DeepSeek reportedly doesn't consider vision part of its AGI path, so it's not on the roadmap — the single biggest feature complaint on both Hacker News and Reddit.

How to Access DeepSeek V4 Pro 0813

graph TD
A[Choose an access route] --> B[DeepSeek official API<br/>model: deepseek-v4-pro]
A --> C[OpenRouter<br/>model: deepseek/deepseek-v4-pro-0813]
B --> D[Enable thinking mode + tool calls]
C --> D
D --> E[Maximize cache hits<br/>never rewrite conversation history]
E --> F[Monitor long agent loops<br/>for early stopping]

You can reach DeepSeek V4 Pro 0813 today through:

DeepSeek's official API — the deepseek-v4-pro endpoint now serves the 0813 build; OpenAI-format, Anthropic-format, Responses API, JSON output, and tool calls are all supported.
OpenRouter — deepseek/deepseek-v4-pro-0813, currently hosted by a single provider (DeepSeek) with 100% uptime over the last three days, ~61 tokens/s throughput, and ~1.56s P50 latency. Early traffic shows Hermes Agent, pi, and Claude Code among the top apps already routing to it.
Self-hosting — the MIT-licensed open weights mean you can run it on your own hardware if you have the VRAM/RAM budget.

🤔 FAQ: DeepSeek V4 Pro 0813

Q: What is DeepSeek V4 Pro 0813?

A: DeepSeek V4 Pro 0813 is the general-availability (GA) release of DeepSeek V4 Pro, a 1.6T-parameter mixture-of-experts model with ~49B active parameters, a 1M-token context window, and up to 384K output tokens, released on August 12, 2026.

Q: How much does DeepSeek V4 Pro 0813 cost?

A: DeepSeek V4 Pro 0813 costs $0.435 per million input tokens on a cache miss, $0.003625 per million on a cache hit, and $0.87 per million output tokens. DeepSeek has announced a significant price increase is planned in the near future.

Q: What is the context length of DeepSeek V4 Pro 0813?

A: DeepSeek V4 Pro 0813 supports a 1,048,576-token (1M) context window with a maximum output of 384,000 tokens — enough for full-codebase analysis and long-horizon agent sessions.

Q: Does DeepSeek V4 Pro 0813 support tool calling and structured outputs?

A: Yes. DeepSeek V4 Pro 0813 supports tool calls, JSON output, the Responses API, both OpenAI and Anthropic API formats, and thinking/non-thinking modes. Reasoning efforts high and xhigh are supported, with xhigh mapping to max reasoning.

Q: Does DeepSeek V4 Pro 0813 support vision?

A: No. DeepSeek V4 Pro 0813 is text-only. DeepSeek has signaled that vision isn't on the roadmap for the V4 Pro line, which is the most common complaint about the model on Hacker News and r/LocalLLaMA.

Q: When was DeepSeek V4 Pro 0813 released?

A: DeepSeek V4 Pro 0813 went live on August 12, 2026, when DeepSeek's official deepseek-v4-pro API endpoint switched from the April preview build to the 0813 build. It appeared on OpenRouter the same day.

Q: Is DeepSeek V4 Pro 0813 open source?

A: Yes. The V4 series (Pro and Flash) was released as MIT-licensed open weights on April 24, 2026, and DeepSeek V4 Pro 0813 retains that license, so you can self-host and commercialize freely.

Summary & Recommended Actions

DeepSeek V4 Pro 0813 is the clearest proof yet that open-weight models have closed the agentic-coding gap to the frontier — 62.7 on DeepSWE, 87.9 on Terminal Bench 2.1, and a geometric mean within ~2 points of Fable 5, at roughly 1/60th of the price. It's not the best model in the world: it lacks vision, it's slower than Grok-class models, and at least one long-loop test found premature early stopping. But for text-only coding agents, batch work, and cost-sensitive pipelines, it resets the value equation.

Your next steps:

Try it for $1: spin up a test on OpenRouter with a real coding task and compare against your current model.
Optimize for cache hits: keep system prompts and conversation history byte-stable — at $0.003625/M, cache hits are where DeepSeek V4 Pro 0813 gets absurdly cheap.
Hedge the price increase: DeepSeek has flagged a "significant" API price hike; test DeepSeek V4 Pro 0813 now while the preview-era pricing lasts, and keep Flash 0731 in your back pocket for high-volume workloads.

Sources: OpenRouter model page & FAQ · DeepSeek API pricing docs · Hacker News discussion · r/LocalLLaMA benchmark thread · OpenRouter announcement on X · karminski3 agent-loop test · GMICloud release analysis

Originally published at: DeepSeek V4 Pro 0813 (2026): Complete Guide to Pricing, Benchmarks & How It Stacks Up Against Fable 5

2026 Complete Guide: What "Flower and Garden Vercel App" Really Is (and How to Use Flower Wand Garden)

cz — Thu, 06 Aug 2026 01:35:33 +0000

2026 Complete Guide: What "Flower and Garden Vercel App" Really Is (and How to Use Flower Wand Garden)

If you searched for flower and garden vercel app, you are not alone — and you are also not quite on the right track. "Flower and garden vercel app" is a common misspelling and a slightly confused search query: people remember a fun browser camera toy that draws flowers with your fingertip, guess it was built on Vercel, and type "flower and garden vercel app" into Google. The tool they are actually looking for is called Flower Wand Garden, live at flowerwandgarden.com. This guide clears up the "flower and garden vercel app" confusion, then explains what flower wand garden is, how to use it, and exactly what it supports — so you can stop searching and start planting.

💡 A quick orientation
There is no product literally named "flower and garden vercel app." The "flower and garden" camera toy you remember is Flower Wand Garden at flowerwandgarden.com. It is free, runs in your browser, and needs no sign-in.

🎯 Core Takeaways (TL;DR)

The name you want is Flower Wand Garden. The "flower and garden vercel app" query is a misspelling; the real tool is flower wand garden, a free browser camera toy at flowerwandgarden.com.
Draw flowers with one fingertip. Flower wand garden uses on-device hand tracking (MediaPipe, 21 landmarks) so your index fingertip becomes a wand that plants a bloom when you pause.
Photos, 15-second videos, no account. Flower wand garden supports photo and short-video capture, live filters, a privacy face mask, multi-hand play, and share or download — all private by default.
Better than the Vercel build. The older flower-wand-garden.vercel.app ("Magical Wands") is a single-hand demo; flower wand garden at flowerwandgarden.com adds multi-hand (up to 4), live filters, a privacy face mask, and 15-second video.

Why "flower and garden vercel app" is a misspelling
Flower Wand Garden vs. the Vercel "Magical Wands" Build
What Is Flower Wand Garden?
How Flower Wand Garden Works
How to Use Flower Wand Garden Step by Step
Everything Flower Wand Garden Supports
Privacy: What Flower Wand Garden Does and Doesn't Upload
Where Is the Public Garden?
Frequently Asked Questions
Final Verdict and Next Steps

Why "flower and garden vercel app" is a misspelling

Let's address the "flower and garden vercel app" search directly, because it is the whole reason this guide exists. "Flower and garden vercel app" is not a product name — it is three search fragments glued together:

"flower and garden" — a close-but-imperfect memory of the brand Flower Wand Garden (people drop the word "wand").
"vercel app" — a guess about where it is hosted, because many indie web tools live on Vercel.

Put together, "flower and garden vercel app" describes a real thing in a slightly wrong way. The camera toy you are picturing — point your finger, hold still, watch a flower bloom — is Flower Wand Garden. So if you arrived here by typing "flower and garden vercel app," the action you actually want is to open flower wand garden, not to keep hunting for a site called "flower and garden vercel app."

⚠️ Note
There really is a Vercel-hosted build at flower-wand-garden.vercel.app — an earlier "Magical Wands" demo that flower wand garden was modeled on — which is why people pair "vercel app" with "flower and garden." That Vercel build is the older, simpler version; the improved release lives at flowerwandgarden.com. See the comparison below.

To make the mapping explicit:

What you typed	What it is	Where to go
flower and garden vercel app	Misspelling of Flower Wand Garden	flowerwandgarden.com
flower and garden	Partial brand recall of Flower Wand Garden	flowerwandgarden.com
flower wand garden	The correct brand	flowerwandgarden.com

From here on, this guide uses the real name — flower wand garden — so you can learn what the "flower and garden vercel app" you were looking for actually does.

Flower Wand Garden vs. the Vercel "Magical Wands" Build

A detail that makes the "flower and garden vercel app" search easier to understand: there really is a Vercel-hosted build at flower-wand-garden.vercel.app — an earlier "Magical Wands" demo that flower wand garden was modeled on. So "flower and garden vercel app" is not only a misspelling; it can also be someone remembering that original Vercel build. The important part is which one you actually want to use.

The Vercel "Magical Wands" build is the older, simpler version. The refined release lives at flowerwandgarden.com, and flower wand garden adds the features that turn a neat finger-drawing demo into something genuinely useful for capturing and sharing:

Feature	flower-wand-garden.vercel.app (Magical Wands)	flowerwandgarden.com (Flower Wand Garden)
Brand & URL	"Magical Wands" on Vercel	Flower Wand Garden at flowerwandgarden.com
Hand tracking	Single-hand flower drawing	MediaPipe, 21 landmarks, fingertip dwell detection
Multi-hand	Not in the earlier build	Up to 4 hands plant together on one screen
Wand modes	Basic flower wand	Flowers (24 original SVG sprites) + twinkling stars
Live filters	Not included	Vivid, oil, watercolor, ink, vintage — baked into exports
Privacy face mask	Not included	Flower or emoji avatar, baked into saved files
Photo capture	Basic	Clean JPEG, no hand skeleton in the export
Video capture	Limited	Up to 15 seconds, timer + auto-stop, TikTok/Reels-ready
Watermark	—	Optional flowerwandgarden.com mark, toggleable per session
Share / download	Basic	Device share sheet or download, no account
Privacy posture	Camera-based demo	On-device; nothing uploaded while you play
Price	Free	Free, no sign-in

The three differences that matter most — and the reason flower wand garden is the better version of the "flower and garden vercel app" you may be remembering:

Plant together (multi-hand). The Vercel build tracks one hand. Flower wand garden tracks up to four hands at once, so friends, family, or a small classroom group can grow a garden together on one screen — ideal for parties and group moments.
Real privacy protection. Flower wand garden runs all hand detection and composition on your device and adds a face mask that covers every face with a flower or emoji avatar, baked into the saved file. The people in your frame stay private when you share.
Creative filters plus full capture. Five live filters (vivid, oil, watercolor, ink, vintage) style both the live frame and the export, and flower wand garden pairs clean photo capture with 15-second, auto-stopping video built for short-form social.

💡 Pro tip
If you land on flower-wand-garden.vercel.app, you are on the older "Magical Wands" build. For multi-hand play, live filters, the privacy face mask, and 15-second video, switch to flowerwandgarden.com — that is the improved flower wand garden release.

What Is Flower Wand Garden?

Flower wand garden is a free, browser-based camera toy that turns your index finger into a virtual flower wand. Open the site, allow your camera, point your index finger, hold still for a moment, and flower wand garden plants a bloom in the air. Keep holding and more flowers appear. The tagline says it simply: "Wave your finger. Grow a little wonder."

There is no app to install, no controller, no drawing lesson, and — in the first release — no sign-in. Flower wand garden is "made for playful imaginations," and everything runs in your browser.

What makes flower wand garden stand out from the generic "flower and garden vercel app" you may have imagined:

On-device hand tracking. Flower wand garden uses a self-hosted MediaPipe Hand Landmarker that reads 21 hand landmarks per hand and follows your index fingertip.
A dwell-to-plant mechanic. A flower appears only after your fingertip stays in place long enough for a progress ring to fill — so flower wand garden rewards a steady hand.
Original art, not stock stickers. Every flower wand garden bloom comes from a library of 24 original SVG flower sprites with soft bloom animations (plus a 250-flower safety limit so the screen never overloads).
Private by default. Camera frames are analyzed in your browser; nothing is uploaded while you play.

✅ Best practice
Flower wand garden works best with the full hand visible and soft front light. Keep the fingertip away from the frame edge and let the hand model settle for the cleanest blooms.

How Flower Wand Garden Works

The mechanics behind flower wand garden are simple to feel and surprisingly clever under the hood. Here is the flow from "open the page" to "saved flower photo":

graph TD
    A[Open flowerwandgarden.com] --> B[Tap Play]
    B --> C[Press Start camera + allow]
    C --> D[MediaPipe tracks 21 hand landmarks]
    D --> E[Follow index fingertip]
    E --> F{Fingertip holds still?}
    F -->|Yes, ring fills| G[Plant a flower or star]
    G --> H[Pick flowers/stars, filter, mask]
    H --> I[Capture photo or 15s video]
    I --> J[Download or share]

The key idea is dwell detection. Flower wand garden does not draw wherever your finger happens to be; it waits for a deliberate pause. That tiny design choice is why flower wand garden feels like "planting" rather than "scribbling," and why it works so well with kids and groups — the pause is a built-in reward for a steady hand.

How to Use Flower Wand Garden Step by Step

Using flower wand garden takes under a minute from search to first bloom:

Go to flowerwandgarden.com. That is the home of flower wand garden — the real site behind the "flower and garden vercel app" query.
Tap Play. Flower wand garden loads the interactive camera experience at /play.
Press Start camera and allow permission. Camera access begins only after you press Start — flower wand garden never opens your camera silently.
Hold one hand in view. Keep your whole hand visible in good, soft front light.
Point and pause. Follow the pink fingertip marker; hold still while the progress ring fills, and flower wand garden plants your first bloom.
Choose your wand. Switch between flowers and twinkling stars, try a live filter, and toggle the privacy mask.
Capture. Take a photo (clean JPEG, no hand skeleton) or record up to 15 seconds of video with a timer and auto-stop.
Download or share. Flower wand garden uses your device's share sheet when available, or saves the file — no account needed.

💡 Pro tip
For social clips, build a small bouquet around an object or your face first, then start the 15-second recording — flower wand garden's auto-stop keeps the clip TikTok- and Reels-ready.

Everything Flower Wand Garden Supports

Here is a full breakdown of what flower wand garden supports in its first release:

Feature	What flower wand garden does
Hand tracking	MediaPipe, 21 landmarks, follows index fingertip with a progress ring
Multi-hand	Up to 4 hands plant at once on one screen
Flower wand	24 original SVG sprites, soft bloom animation, 250-flower limit
Star wand	Randomly sized, randomly colored twinkling stars that drift
Live filters	Vivid, oil, watercolor, ink, vintage — baked into exports
Privacy mask	Covers faces with a flower or emoji avatar, baked into saved files
Photo mode	Composites camera + garden into a clean JPEG, no hand skeleton
Video mode	Up to 15 seconds via MediaRecorder + canvas captureStream, timer + auto-stop
Watermark	Optional flowerwandgarden.com mark, toggleable per session
Export	Device share sheet or download, no account
Languages	English-only public UI in v1
Privacy	All analysis on-device; nothing uploaded while you play

A few of these deserve a closer look:

Two wand modes

Flower wand garden ships two wands. The flower wand plants colorful original blooms with soft bloom animations. The star wand sprinkles randomly sized, randomly colored twinkling stars that drift across the frame. Both are saved into your photo or video exactly as they appear on screen.

Live filters and the privacy face mask

Flower wand garden applies your chosen filter to the live camera frame and bakes it into the exported file — so the vivid, oil, watercolor, ink, or vintage look stays on the saved photo or video. The mask control detects each face on your device and covers it with a flower or emoji avatar you pick, also baked into the export. That makes flower wand garden unusually share-friendly: the people in your frame stay private when you post.

Photo vs. short video

Photo mode has the widest device support and produces a clean JPEG without the on-screen hand skeleton. Video mode records up to 15 seconds — sized for TikTok, Reels, and messages — and appears only where the browser supports MediaRecorder and canvas captureStream.

Privacy: What Flower Wand Garden Does and Doesn't Upload

Privacy is where flower wand garden is deliberately different from a typical "flower and garden vercel app" assumption. In its first release:

Nothing is uploaded while you play. Hand detection, flower animation, photography, and video composition all run locally in your browser.
A file leaves only when you choose. Flower wand garden sends a finished file out only when you explicitly download it or use your device's share sheet.
Camera tracks stop on exit. Every camera track stops when you leave the Play page.
No account, no upload, no moderation feed yet. The first release intentionally has no public media storage, no public media feed, and no moderation — those come later, behind sign-in.

⚠️ Note
The tracking dots and hand skeleton you see on screen are guidance only. They are never saved into your exported photo or video — flower wand garden exports the camera image, the flower art, and the optional watermark, nothing else.

Where Is the Public Garden?

You might expect a "garden" product to show off a public gallery — and that is coming. The /garden page in flower wand garden currently shows illustrated "Demo" preview cards and a Coming Soon message. A moderated Public Garden for shared photos and videos is the next planned phase:

Publishing will require sign-in.
Submissions will be reviewed before anything becomes public.
Seasonal collections and new wand ideas may follow.

Until that work is complete, flower wand garden keeps the experience private and on-device — which is also why the "flower and garden vercel app" you were searching for is best understood as a personal camera toy first, and a social gallery later.

🤔 Frequently Asked Questions

Q: What is "flower and garden vercel app"?

A: "Flower and garden vercel app" is a misspelling. The camera toy it refers to is Flower Wand Garden at flowerwandgarden.com — a free browser tool that grows flowers when you point your index finger and pause. There is no product named "flower and garden vercel app."

Q: What is flower wand garden?

A: Flower wand garden is a free browser camera experience that tracks your hand and turns the tip of your index finger into a virtual flower wand. Hold still to plant a bloom, then take a photo or record a short video — no sign-in required.

Q: Does flower wand garden upload my camera?

A: No. In the first release, flower wand garden performs hand detection, flower animation, photography, and video composition locally in your browser. A finished file leaves the page only when you download it or use your device's share sheet.

Q: How do I make a flower appear?

A: Show one hand, point with your index finger, and keep the fingertip within the progress ring. Flower wand garden creates the first bloom after a brief pause and keeps adding flowers while you stay nearby.

Q: Can more than one person plant at once?

A: Yes. Flower wand garden can track up to four hands in the same frame, so friends, family, or a small classroom group can build a garden together on one screen.

Q: What devices does flower wand garden support?

A: Flower wand garden works on current mobile and desktop browsers with camera access. Photo mode has the widest support; video mode appears only where the browser provides MediaRecorder and canvas captureStream.

Q: Are the tracking dots saved in my photo or video?

A: No. Flower wand garden shows the hand skeleton and fingertip progress only as guidance. The exported media contains the camera image, flower artwork, and the optional flowerwandgarden.com watermark.

Q: Can I hide faces for privacy?

A: Yes. Turn on the Mask control and flower wand garden covers each face with a flower or emoji avatar, baked into the exported file so people stay private when you share.

Q: Where is the public gallery?

A: The Public Garden is the next phase of flower wand garden. The first release ships the private camera experience; the later gallery will require sign-in for publishing and review submissions before they become public.

Final Verdict and Next Steps

If you came here searching for flower and garden vercel app, you now have the answer: the tool you remember is Flower Wand Garden at flowerwandgarden.com. "Flower and garden vercel app" was a misspelling; flower wand garden is the real, free, browser-based camera toy that grows flowers from your fingertip — with photo and 15-second video capture, live filters, a privacy face mask, multi-hand play, and no account required.

Next steps:

Open flowerwandgarden.com and tap Play to try flower wand garden yourself.
Plant a few flowers, then switch to the star wand and try a live filter.
Record a 15-second clip with the face mask on for a share-ready, privacy-safe video.

Either way, you have found what "flower and garden vercel app" was pointing at all along — and your first flower is one gesture away.

Originally published at: 2026 Complete Guide: What "Flower and Garden Vercel App" Really Is (and How to Use Flower Wand Garden)

2026 Complete Guide: What Your Life Path Calculator Number Really Means (and How to Get the Most From It)

cz — Tue, 04 Aug 2026 03:47:48 +0000

2026 Complete Guide: What Your Life Path Calculator Number Really Means (and How to Get the Most From It)

Wondering what your date of birth says about your personality, strengths, and recurring life patterns? A life path calculator reduces your birth date to a single number from 1 to 9 — or one of the Master Numbers 11, 22, and 33 — and turns it into a practical self-reflection reading. Unlike most numerology sites that hide the math, the life path calculator at lifepathcalculator.app shows every calculation step, keeps all fixed results free, and offers an optional private AI reading only when you want a deeper report. This guide covers what a life path calculator does, how the arithmetic works, what each number means, and how to get the most useful reading — with no sign-up required for the free result.

💡 A quick orientation
A life path calculator is a symbolic self-reflection tool, not a scientific personality test. The best ones show you the full calculation, give the same result for the same birth date every time, and stop short of claiming to predict your future. Lifepathcalculator.app is built exactly that way.

🎯 Core Takeaways (TL;DR)

Free and transparent. The life path calculator is 100% free: number, meaning, strengths, challenges, life lesson, and the complete calculation process — no account needed.
Deterministic by design. All fixed results come from versioned pure code, so the same birth date always produces the same Life Path Number. AI can expand a result but can never alter it.
One optional paid layer. A private AI reading costs 100 credits, with one-time packs from $2.99 to $29.99. No subscription, no auto-renewal, automatic refund if generation fails.

What Is a Life Path Calculator?
How the Life Path Calculation Works
The 12 Life Path Numbers and Their Meanings
Master Numbers 11, 22, and 33
How to Use the Life Path Calculator Step by Step
What You Get for Free vs. What Costs Credits
The Optional AI Reading: What's Inside
The Other Numerology Tools on the Same Site
How to Read Your Result Honestly
Frequently Asked Questions
Final Verdict and Next Steps

What Is a Life Path Calculator?

A life path calculator is a numerology tool that reduces your full date of birth — month, day, and year — to a single number called your Life Path Number. In Pythagorean numerology, that number is used as a symbolic description of recurring patterns: how you tend to lead, cooperate, create, build, explore, care, question, achieve, or serve.

What makes the life path calculator at lifepathcalculator.app different is transparency. Instead of showing one number and asking you to trust it:

Every reduction in the calculation is displayed, so you can verify the math by hand in about a minute.
The engine version that produced the result is recorded and shown with it.
The fixed number is kept strictly separate from any optional AI interpretation.

✅ Best practice
The same birth date should always give the same result from a life path calculator. If a site gives you a different number on every visit, the arithmetic isn't trustworthy — move on.

How the Life Path Calculation Works

The method used by this life path calculator is simple and consistent:

Reduce the month to a single digit.
Reduce the day to a single digit.
Reduce the year to a single digit.
Add the three results together.
Reduce the total again (while preserving Master Numbers 11, 22, and 33).

Here's the example the site itself demonstrates: someone born on March 17, 1985 gets 3 + 8 + 5 = 16, then 1 + 6 = 7, so their Life Path Number is 7 — the Seeker.

Input	Reduction	Result
Month (March)	3	3
Day (17)	1 + 7	8
Year (1985)	1 + 9 + 8 + 5 = 23 → 2 + 3	5
Combined	3 + 8 + 5	16 → 1 + 6 = 7

The site shows this exact process on the result page, step by step. That's the contract of a trustworthy life path calculator: you can check every number yourself.

The 12 Life Path Numbers and Their Meanings

A life path calculator can produce one of twelve results: the nine single digits plus three Master Numbers. Here is a compact reference for all of them:

Life Path Number	Name	Core Theme	Signature Strengths
1	The Pioneer	Independence and initiative	Courage, original thinking
2	The Diplomat	Cooperation and sensitivity	Empathy, partnership
3	The Creator	Expression and imagination	Creativity, storytelling
4	The Builder	Structure and reliability	Discipline, organization
5	The Explorer	Movement and variety	Versatility, resourcefulness
6	The Nurturer	Care and responsibility	Service, warmth
7	The Seeker	Analysis and meaning	Insight, research
8	The Executive	Ambition and results	Leadership, resilience
9	The Humanitarian	Compassion and purpose	Generosity, perspective
11	The Intuitive	Inspiration and vision	Intuition, influence
22	The Master Builder	Large visions into reality	Scale, endurance
33	The Master Teacher	Compassionate guidance	Devotion, uplift

Each result from the life path calculator also comes with a set of potential challenges (written as reflection prompts, not verdicts) and a one-line life lesson. For example, a 7's lesson is "Let knowledge become lived wisdom", while an 8's is "Define success by integrity as well as achievement."

Every Life Path Number has its own dedicated artwork and guide page — from The Pioneer (1) to The Humanitarian (9), plus the three Master Number cards (11, 22, 33) — so your result page always reflects the exact number you calculated.

Master Numbers 11, 22, and 33

Most birth dates reduce to a single-digit life path number, but some reduce to 11, 22, or 33. A life path calculator that preserves Master Numbers treats them as intensified versions of 2, 4, and 6:

11 (The Intuitive) — inspiration and insight, with the challenge of nervous intensity.
22 (The Master Builder) — translating large visions into practical reality, with the challenge of overwhelm.
33 (The Master Teacher) — compassionate service and guidance, with the challenge of self-sacrifice.

Important nuance: the site does not claim Master Number holders are "more evolved" or guaranteed unusual success. It means the symbolic description comes with stronger potential and stronger pressure — and the dedicated guide pages for Life Path Numbers 11, 22, and 33 explain how to work with that honestly. This life path calculator marks Master Number results clearly so you know exactly what you're looking at.

How to Use the Life Path Calculator Step by Step

Using the life path calculator at lifepathcalculator.app takes less than a minute:

Open the homepage. The free life path calculator form is right on the front page.
Pick your date of birth with the date picker.
Press "Calculate My Life Path." No sign-up, no payment, works on any device.
Read your free result. You get your Life Path Number, its name and summary, natural strengths, potential challenges, and your life lesson — plus the complete calculation process.
Share or save. Download a branded PNG card, or copy a private (unindexed) result link for later.
Optionally go deeper. If you want a longer, personalized report, sign in and unlock a private AI reading for 100 credits.

⚠️ Note
Sign-in is only needed for the paid AI reading. The core life path calculator — including the full calculation trace and PNG card — works completely anonymously.

What You Get for Free vs. What Costs Credits

This is the part most people care about, so here is a clean breakdown:

Feature	Free	Paid (100 credits)
Life Path Number + meaning	✅	—
Strengths, challenges, life lesson	✅	—
Complete calculation steps (verifiable by hand)	✅	—
Engine version displayed	✅	—
Branded share card (PNG)	✅	—
Private, unindexed result link	✅	—
Private AI reading (~structured report)	—	✅
Reading export as PNG	—	✅

The "100 credits" line is consistent across every tool on the site: one reading equals one deep-dive, no matter which calculator produced the fixed result.

The Optional AI Reading: What's Inside

The optional AI reading is the only paid feature on the site, and it's structured like a coaching session rather than a horoscope. Generated only after your fixed Life Path Number exists, the private report for a life path calculator result covers:

Core Personality Pattern — connects the fixed number with recurring motivations and choices, without treating the number as a diagnosis.
Career and Life Direction — working styles, useful environments, and the tension between ambition, meaning, and sustainable effort.
Love, Money, and Inner Conflict — relationship needs, definitions of success, and the trade-offs currently asking for attention.
Personalized Action Plan — practical reflection questions plus one small, reversible next action.

The reading uses the same locale as your free result, stays private to your account, and never changes the fixed number or its calculation — AI can expand, but it cannot alter. If generation fails, the credits for that attempt are refunded automatically (the charge is idempotent).

Credit Pack Pricing

Credits are a one-time purchase through Stripe or PayPal. No subscription, no auto-renewal.

Pack	Credits	Price	Per-Reading Cost
Starter	100	$2.99	$2.99
Standard (recommended)	300	$7.99	~$2.66
Pro (best value)	1,500	$29.99	~$2.00

If you only want to try one reading, the Starter pack is the cheapest entry. If you plan to run several tools — Life Path, compatibility, Personal Year, the Oracle — the Pro pack offers the lowest effective rate.

The Other Numerology Tools on the Same Site

The life path calculator is the entry point, but the same site hosts a full family of free numerology tools, all in the same transparent style:

Life Path Compatibility Calculator — compares two birth dates and returns one of four profiles: Mirror Paths, Natural Rhythm, Growth Partners, or Dynamic Contrast. Same fixed pair, same result, every time.
Personal Year Calculator — combines your birth month and day with a target year (1900–2200) to describe the theme of that year.
Numerology Calculator (Full Numerology) — your five core numbers: Life Path, Expression, Soul Urge, Personality, and Birthday, from your birth name and birth date.
Soul Urge Number Calculator — the vowels of your full birth name, with a "Y as vowel" option.
Expression Number Calculator — every letter of your full birth name.
Birthday Number Calculator — the day of your birth, reduced.
Lo Shu Grid Calculator — a 3×3 grid built from the digits in your birth date, showing which attention modes are present, repeated (a strength turned up), or missing (a quality that may need more conscious practice).
AI Oracle — a free reflection tool for one specific situation, returning one of six fixed signs: Peace, Delay, Good News, Conflict, Small Blessing, or Emptiness. You can cast by current time (converted to lunar month, day, and hour branch in your time zone), a specific time (converted to Asia/Shanghai), three numbers of your own, or three securely generated random numbers. The sign is fixed arithmetic — AI is never used to pick it.

The Oracle's counting is inclusive: the position where a count begins counts as one. The lunar month sets the starting landing, the lunar day counts forward from there, and the two-hour branch (Zi through Hai) counts forward again — three landings in total, which become the three stages of your movement. Each of the six signs has its own artwork card, like this example:

Every tool shows its calculation process, keeps fixed results free, and offers the same optional private AI reading. That makes this more than a single life path calculator: it's a complete numerology toolkit with one consistent, verifiable engine.

How to Read Your Result Honestly

The most useful way to use a life path calculator is as a mirror, not a script. A few guidelines that make the difference between a meaningful reading and a meaningless one:

Notice your reaction. Read the description of your number and pay attention to which sentences produce recognition, resistance, or curiosity — that signal is more useful than the number itself.
Translate themes into behavior. Turn one broad theme into a single observable habit you can check against real life. "Life Path 7 overthinking" becomes "did I decide anything today, or just analyze?"
Keep what fits, set aside what doesn't. A life path number describes tendencies, not destiny. It cannot know your history, culture, health, or environment.
Respect the boundaries. The site is explicit: numerology is a reflective tradition, not professional advice, and no result is a command or a guaranteed prediction.

💡 Pro tip
If a reading feels wrong, do not force a match. Your lived knowledge of your own life always outweighs a symbolic number — a good life path calculator exists to help you ask better questions, not to hand you answers.

Frequently Asked Questions

Q: Is the life path calculator free?

A: Yes. The life path calculator at lifepathcalculator.app is free: your number, its meaning, strengths, challenges, life lesson, and every calculation step require no sign-up. Only the optional private AI reading costs credits.

Q: How is my Life Path Number calculated?

A: The calculator reduces your birth month, day, and year to single digits, adds them, and reduces the total, preserving Master Numbers 11, 22, and 33. The result page shows each step, so you can verify the calculation by hand.

Q: Can the AI change my number?

A: No. All fixed results come from versioned pure code, and the AI reading is generated only after the fixed result exists. The AI can expand and interpret your life path calculator result, but it can never recalculate or replace it.

Q: What are Master Numbers?

A: 11, 22, and 33 are Master Numbers preserved by this life path calculator. They represent intensified versions of 2, 4, and 6: the Intuitive, the Master Builder, and the Master Teacher.

Q: Is numerology scientific?

A: No. Numerology is a symbolic self-reflection tradition, not a scientific test or a prediction method. Use the life path calculator to ask better questions about your patterns — not to make decisions that affect your health, money, or safety.

Q: What happens if an AI reading fails?

A: The charge is idempotent, and failed generation attempts automatically refund the credits used for that attempt.

Q: Can I share my result?

A: Yes. The result page offers a branded PNG card and a public but unindexed result link. Your birth date and other private inputs are never exposed on the shared card.

Final Verdict and Next Steps

If you want a life path calculator that respects your time, your privacy, and your intelligence, lifepathcalculator.app is the one to try first. Every fixed calculation is free and verifiable by hand, results are deterministic so they're shareable and trustworthy, the twelve number guides are genuinely useful, and the optional AI reading is structured reflection rather than fortune-telling. Pricing is honest — one-time credits from $2.99, no subscription, refunds on failure — and the entertainment boundary is repeated everywhere, so no one mistakes a number for a prognosis.

Next steps:

Visit lifepathcalculator.app and run your birth date through the free life path calculator.
Read your number's guide page, then try the Life Path Compatibility Calculator with a partner or friend.
If a specific situation is on your mind, cast the AI Oracle — and if you want the deeper story, unlock one private reading.

Either way, you just used a life path calculator the way it was meant to be used — as a mirror, not a fortune cookie.

Originally published at: 2026 Complete Guide: What Your Life Path Calculator Number Really Means

Qwen 3.8 Max vs GLM 5.2 vs Kimi K3 vs DeepSeek V4 Flash (2026): The Complete Frontier Model Comparison

cz — Mon, 03 Aug 2026 03:52:26 +0000

Qwen 3.8 Max vs GLM 5.2 vs Kimi K3 vs DeepSeek V4 Flash (2026): The Complete Frontier Model Comparison

🎯 Key Takeaways (TL;DR)

Kimi K3 (Moonshot, July 16, 2026) is the only one of the four with fully verified third-party scores: 57 on the Artificial Analysis Intelligence Index, #4 of 189 models — the highest ever for an open-weight model. It is also #1 on Arena's Frontend Coding leaderboard (1,679 Elo, 483,895 blind votes).
GLM 5.2 (Zhipu, June 13–17, 2026, ~744B params) is the verified coding-and-agent specialist: #1 globally on Code Arena and Design Arena, with MIT weights already on Hugging Face and a budget-friendly $0.29/M token rate on OpenRouter.
Qwen 3.8 Max (Alibaba, July 19, 2026, 2.4T params, 95B active) is the newest flagship — the first Max-scale model with open-weight plans, officially claiming to trail "only Fable 5". Its official announcement (Alibaba Qwen WeChat blog) includes benchmark tables, but no third party has scored it yet, so treat all headline numbers as vendor claims for now.
DeepSeek V4 Flash 0731 (July 31, 2026, 284B total / 13B active) is the value king: it beats GLM 5.2 on nearly every agentic benchmark on DeepSeek's own Hugging Face table (Terminal-Bench 2.1: 82.7 vs 81.0; DeepSWE: 54.4 vs 46.2) at just $0.14 / $0.28 per million tokens — about 1.1% of Claude Opus 4.8's output price.

⚠️ Accuracy note: This article clearly separates officially claimed numbers (vendor-published) from independently verified numbers (Artificial Analysis, Arena, third-party evals). As of August 3, 2026, Qwen 3.8 Max has official but not yet independently verified benchmarks; Kimi K3, GLM 5.2, and DeepSeek V4 Flash 0731 have both.

📑 Table of Contents

Why This Four-Way Comparison Matters in 2026
At a Glance: Side-by-Side Specification Table
Release Timeline: A Two-Month Race
Benchmarks: Official Claims vs Independent Verification
Agentic & Coding Benchmarks Head-to-Head
Pricing Breakdown: API, OpenRouter, and Cache
Context Window & Multimodal Capabilities
Open Weights, Licensing & Deployment
How to Choose Between the Four Models
Frequently Asked Questions
Final Verdict & Next Steps

Why This Four-Way Comparison Matters in 2026 {#why-it-matters}

The summer of 2026 is the first time four Chinese labs shipped frontier-scale models within six weeks of each other. If you are building a product on LLMs today, this Qwen 3.8 Max vs GLM 5.2 vs Kimi K3 vs DeepSeek V4 Flash decision determines your benchmark ceiling, your per-token cost, and whether you can self-host at all. Three reasons this matchup matters:

The open-weight gap closed. Kimi K3 (2.8T), GLM 5.2 (~744B), and Qwen 3.8 Max (2.4T) all ship or promise open weights under permissive licenses, while DeepSeek V4 Flash 0731's 284B weights are expected within weeks. For the first time, frontier-adjacent performance is available off-cloud.
Scale is diverging, not converging. You can now choose between a 2.8-trillion-parameter monster (Kimi K3), a 2.4T multimodal flagship (Qwen 3.8 Max), a 744B coding specialist (GLM 5.2), and a 284B-parameter / 13B-active value model (DeepSeek V4 Flash 0731) that outperforms models many times its size.
Verified data is finally available for three of four. Artificial Analysis now scores Kimi K3 (57), GLM 5.2 (51), and DeepSeek V4 Flash 0731 (50) on its Intelligence Index. Qwen 3.8 Max remains the open question.

💡 Pro Tip: The single most important accuracy rule in 2026: check whether a benchmark number is vendor-published or third-party-verified before you quote it in a blog or a slide deck.

At a Glance: Side-by-Side Specification Table {#spec-table}

Specification	Qwen 3.8 Max (Alibaba)	GLM 5.2 (Zhipu)	Kimi K3 (Moonshot)	DeepSeek V4 Flash 0731
Release date	July 19, 2026 (preview)	June 13–17, 2026	July 16, 2026	July 31, 2026 (0731 checkpoint)
Total parameters	2.4T (official)	~744B	2.8T	284B
Active parameters	95B (official)	~40B	~50B (16 of 896 experts)	13B (6 of 256 experts per token)
Architecture	MoE (based on Qwen 3.5)	MoE + upgraded DeepSeek Sparse Attention	Stable LatentMoE + KDA hybrid attention	MoE, 1 shared + 256 routed experts, hash routing
Context window	1M tokens (official)	1M tokens	1M tokens	1M tokens (1,048,576)
Native modalities	Text, image, video, documents	Text-first	Text, image, audio, video	Text only
Open weights	Promised "next week" (announcement ~Jul 30)	MIT, on Hugging Face now	MIT, full weights July 27, 2026	Expected "in coming weeks"
AA Intelligence Index	Not yet scored (official claims only)	51 (verified)	57 (verified, #4 of 189)	50 (verified)
OpenRouter ID	n/a (Token Plan only)	`z-ai/glm-5.2`	`moonshotai/kimi-k3`	`deepseek/deepseek-v4-flash-0731`

Release Timeline: A Two-Month Race {#timeline}

graph LR
    A[Jun 13-17: GLM 5.2] --> B[Jul 16: Kimi K3]
    B --> C[Jul 19: Qwen 3.8 Max preview]
    C --> D[Jul 27: Kimi K3 weights drop]
    D --> E[Jul 31: DeepSeek V4 Flash 0731]
    E --> F[Early Aug: Qwen 3.8 Max weights? DeepSeek weights?]

June 13–17, 2026 — Zhipu releases GLM 5.2 (~744B), topping Code Arena and Design Arena within weeks, trained on Huawei Ascend hardware.
July 16, 2026 — Moonshot launches Kimi K3 (2.8T) at WAIC Shanghai, the largest open-weight model ever released.
July 19, 2026 — Alibaba previews Qwen 3.8 Max (2.4T) at WAIC, claiming "second only to Fable 5".
July 27, 2026 — Kimi K3 full MIT weights land on Hugging Face.
July 31, 2026 — DeepSeek ships the V4 Flash 0731 checkpoint (same 284B/13B architecture, fully re-post-trained), producing a huge agentic benchmark jump.

Benchmarks: Official Claims vs Independent Verification {#benchmarks}

The Qwen 3.8 Max vs GLM 5.2 vs Kimi K3 vs DeepSeek V4 Flash benchmark picture has two layers. Here is the verified layer first.

Independently Verified: Artificial Analysis Intelligence Index

Model	Intelligence Index	Global Rank	Notes
Kimi K3 (max)	57	#4 of 189	Highest ever for an open-weight model; ~on par with Claude Opus 4.8 (~56)
GLM 5.2 (max)	51	Top 10	Verified across full eval suite
DeepSeek V4 Flash 0731 (max)	50	—	Within 1 point of GLM 5.2; on par with Gemini 3.6 Flash (50); 1 point behind Muse Spark 1.1 (51)
Qwen 3.8 Max	Not scored	—	No third-party evaluation published as of Aug 3, 2026

Reference points: Claude Fable 5 ~60 (#1), GPT-5.6 Sol ~59 (#2).

Officially Claimed: Qwen 3.8 Max (Alibaba's Announcement)

Alibaba's official Qwen announcement (published on the Qwen WeChat account, ~July 30, 2026) is the source the community has been asking for. Confirmed specs from that post: 2.4T total parameters, 95B active parameters, 1M-token context, and first Max-scale model with open-weight plans ("weights next week"). The announcement's performance tables are published as images, but the textual results include:

E-Commerce Bench (365-day simulated e-commerce, ¥100,000 start): finished with ¥416,252 total cash (4.16× return) — 38% higher than runner-up GLM 5.2 and 152% better than Qwen 3.7-Max; year-end-promotion net profit was ~2.4× GLM 5.2's.
Autonomous chip design (GCD/RSA crypto accelerator): from first working design at 8,298 gates to 678 gates after ~500 interaction rounds — stated as best among all models evaluated.
Autonomous research loop: reproduced a paper's full pipeline in ~37 hours, then independently proposed 18 improvements and beat the original method by +2.7 points on AIME24.
Long-horizon coding: 265 commits, 127 PRs, 151 issues across ~16 autonomous days on the oh-my-cli project (GitHub: qwen-code-dev-bot/oh-my-cli).

Verdict on Qwen 3.8 Max numbers: officially published and detailed, but not yet independently verified — Artificial Analysis and LMArena have not scored it. Qwen 3.7-Max's verified baseline (AA Index 56.6 at launch; GPQA-Diamond 92.4, SWE-bench Verified 80.4, Terminal-Bench 2.0 69.7) remains the only family-level third-party reference.

⚠️ Note: The only independent data point on Qwen 3.8 Max so far is Trilogy AI's single blind StackPerf run: Qwen3.8-Max-Preview 80 vs Kimi K3 83. One run, one task — a data point, not a verdict.

Agentic & Coding Benchmarks Head-to-Head {#agentic-benchmarks}

DeepSeek's Hugging Face card for V4 Flash 0731 publishes a direct four-way comparison on agentic benchmarks (model-reported, DeepSeek's own harness). It is the cleanest apples-to-apples table currently public:

Benchmark	DS V4 Flash 0731	DS V4 Flash (prev)	DS V4 Pro (prev)	GLM 5.2	Opus 4.8
Terminal-Bench 2.1	82.7	61.8	72.1	81.0	85.0
NL2Repo	54.2	39.4	38.5	48.9	69.7
Cybergym	76.7	38.7	52.7	—	83.1
DeepSWE	54.4	7.3	12.8	46.2	58.0
Toolathlon-Verified	70.3	49.7	55.9	59.9	76.2
Agents' Last Exam	25.2	15.8	16.5	23.8	25.7
DSBench-FullStack	68.7	37.0	41.8	61.8	71.6
DSBench-Hard	59.6	25.8	31.1	54.5	71.7

Read carefully: DeepSeek V4 Flash 0731 (13B active) beats GLM 5.2 (~40B active) on every row where both appear, and comes within a few points of Claude Opus 4.8 — while its 0731 checkpoint's DeepSWE jumped from 7.3 to 54.4 versus the preview. The Medium/community assessment that the 0731 build sits at "Claude Opus 4.6 level on agentic benchmarks" is consistent with these tables.

For coding specifically, the verified standings are:

Coding Benchmark	Winner
Arena Frontend Coding	Kimi K3 — 1,679 Elo, #1 (483,895 blind votes; led 6 of 7 domains)
Code Arena (Z.ai blind eval)	GLM 5.2 — #1 globally
Design Arena	GLM 5.2 — #1, Elo 1360
SWE-bench Verified	Kimi K3 ~78% / GLM 5.2 77.8% — near-tie
HumanEval	Kimi K3 88.3 (family-reported)
Qwen 3.7-Max baseline (SWE-bench Verified)	80.4 — the family reference until 3.8 is verified

Pricing Breakdown: API, OpenRouter, and Cache {#pricing}

Model	Input / 1M	Output / 1M	Cached Input / 1M	Notes
DeepSeek V4 Flash 0731	$0.14	$0.28	$0.0028 (98% off)	~1.1% of Opus 4.8's output price; 2,500 concurrent requests; max output 384K
GLM 5.2	$0.29 (OpenRouter) / ¥8 (Zhipu API)	$0.29	—	Free tier via NVIDIA NIM
Kimi K3	Premium tier (Moonshot API)	Premium tier	—	Free at kimi.com and Kimi Code
Qwen 3.8 Max	Preview credits only (Token Plan / Qoder)	Preview credits only	—	Preview at 1/10th rate, 1/50th overnight; no public per-token price yet

Cost-per-task reality check: DeepSeek V4 Flash 0731 is dramatically cheaper per token, and it is 12% more token-efficient than its predecessor (206M vs 234M output tokens for the same Intelligence Index run). Kimi K3's reasoning depth often solves tasks in fewer total tokens, which can offset its premium rate. Always benchmark end-to-end cost per task, not just the rate card.

Context Window & Multimodal Capabilities {#context-multimodal}

All four models support a 1M-token context window — one of the quiet convergences of 2026. The multimodal story differs sharply:

Model	Multimodal?	Details
Kimi K3	✅ Native	Text, image, audio, video in one prompt — the broadest single-model modality support
Qwen 3.8 Max	✅ Native	First Qwen multimodal above 1T params; official demos cover 200+ page reports, 100+ hour videos ("Video Graph memory"), Vlog editing, screenshot-to-frontend, Blender 3D; RecreationBench for app replication; Qwen-MM-Plugins toolkit
GLM 5.2	⚠️ Text-first	Vision via companion GLM-4.5V family, not a unified architecture
DeepSeek V4 Flash 0731	❌ Text only	Confirmed by Artificial Analysis: text input/output only

If your workload needs see + reason + act in one model, the choice narrows to Kimi K3 or Qwen 3.8 Max. If you run pure text agents, DeepSeek V4 Flash 0731's narrow modality surface is a feature: smaller deployment, lower cost, no vision tax.

Open Weights, Licensing & Deployment {#open-weights}

Model	License	Weights Status	Self-Host Footprint
Kimi K3	MIT	Live since July 27, 2026 (`moonshotai/Kimi-K3`)	Multi-node H100/MI300 (≥8 GPU); vLLM / SGLang
GLM 5.2	MIT	Live now (`zai-org/GLM-5.2`)	Single-node 8×H100 or 4×MI300; vLLM, SGLang, llama.cpp
Qwen 3.8 Max	TBD	Promised "next week" (announcement ~Jul 30); no license stated yet	Unclear until weights drop; 95B active suggests 8-GPU-class nodes
DeepSeek V4 Flash 0731	Expected permissive	"Coming weeks" per Artificial Analysis	13B active — runs on small clusters; community reports 2×DGX Spark setups

✅ Best Practice: If you need open weights today, pick GLM 5.2 (744B) or Kimi K3 (2.8T). If you want the smallest self-hostable frontier-adjacent model, wait for DeepSeek V4 Flash 0731 weights — 13B active is a dramatically cheaper serving story. Qwen 3.8 Max's weight release date and license were not yet confirmed as of August 3, 2026.

How to Choose Between the Four Models {#how-to-choose}

graph TD
    A[What matters most?] --> B{Verified scores<br/>before you bet?}
    A --> C{Scale & multimodal<br/>in one model?}
    A --> D{Lowest cost<br/>per task?}
    A --> E{Open weights<br/>today?}
    B -->|Yes| F[Kimi K3: AA 57, verified #4]
    C -->|Yes| G[Kimi K3 or Qwen 3.8 Max]
    D -->|Yes| H[DeepSeek V4 Flash 0731: $0.14/$0.28]
    E -->|Yes| I[GLM 5.2 today / Kimi K3 live now]
    G --> J{Want vendor<br/>benchmarks too?}
    J -->|Yes| K[Qwen 3.8 Max official tables + demos]
    J -->|No| L[Kimi K3 native 4-modality]

Recommendations by workload:

Production coding agent, today, with verified evals → Kimi K3 (AA 57, Frontend Coding #1) or GLM 5.2 (Code Arena #1, cheaper per token).
Agentic loops on a tight budget → DeepSeek V4 Flash 0731 — beats GLM 5.2 on DeepSeek's agentic table at ~2% of the premium cost.
Autonomous long-horizon work (research, e-commerce, chip design) with vendor evidence → Qwen 3.8 Max — the official case studies (4.16× E-Commerce return, 678-gate chip) are the strongest published demos; just verify before you scale.
Native multimodal single model → Kimi K3 (4 modalities) or Qwen 3.8 Max (vision + video + GUI agents).
Self-host on commodity hardware → DeepSeek V4 Flash 0731 (13B active) or GLM 5.2 (single 8-GPU node).

🤔 Frequently Asked Questions {#faq}

Q: Which of the four models has the best verified benchmarks?

A: Kimi K3 — 57 on the Artificial Analysis Intelligence Index, #4 of 189 models, the highest ever recorded by an open-weight model, plus #1 on Arena Frontend Coding (1,679 Elo). GLM 5.2 (51) and DeepSeek V4 Flash 0731 (50) are close to each other on the Index.

Q: Is Qwen 3.8 Max really "second only to Fable 5"?

A: That is Alibaba's official claim, with detailed internal benchmark tables and case studies published in its announcement (E-Commerce Bench 4.16× return, 38% above GLM 5.2; 152% above Qwen 3.7-Max; chip design to 678 gates). No third party has verified it yet as of August 3, 2026. Treat it as a strong vendor claim pending independent scores.

Q: How can DeepSeek V4 Flash 0731 (13B active) beat GLM 5.2 (40B active)?

A: The 0731 checkpoint is the same 284B/13B architecture as V4 Flash but fully re-post-trained, which DeepSeek's Hugging Face table shows delivering large agentic gains (DeepSWE 7.3 → 54.4; Terminal-Bench 2.1 61.8 → 82.7). Post-training quality, not raw scale, drives its agentic performance — that is the 2026 lesson this model teaches.

Q: What is the cheapest model here?

A: DeepSeek V4 Flash 0731: $0.14/M input, $0.28/M output, and $0.0028/M cached input (98% discount) — roughly 1.1% of Claude Opus 4.8's output price, with a 2,500-concurrency limit. GLM 5.2 at $0.29/M on OpenRouter is second.

Q: Which models can I run locally?

A: GLM 5.2 (MIT weights live) and Kimi K3 (MIT weights live since July 27) today. DeepSeek V4 Flash 0731 weights are expected in coming weeks and are the easiest to serve (13B active). Qwen 3.8 Max promised weights "next week" in its announcement, but no date or license was confirmed as of August 3, 2026.

Q: Do all four support 1M-token context?

A: Yes — Qwen 3.8 Max (officially), GLM 5.2, Kimi K3, and DeepSeek V4 Flash 0731 (1,048,576 tokens) all ship 1M-token context windows.

Q: Which is best for multimodal tasks?

A: Kimi K3 (native text/image/audio/video) and Qwen 3.8 Max (native image/video/documents plus GUI-agent capabilities like RecreationBench). GLM 5.2 is text-first (vision via companion models), and DeepSeek V4 Flash 0731 is text-only.

Final Verdict & Next Steps {#verdict}

The Qwen 3.8 Max vs GLM 5.2 vs Kimi K3 vs DeepSeek V4 Flash comparison in August 2026 resolves into four distinct bets:

Bet on verification: Kimi K3 — the only model here with frontier-level third-party scores.
Bet on coding + open weights today: GLM 5.2 — Code Arena #1, MIT weights live, cheap tokens.
Bet on the newest flagship: Qwen 3.8 Max — biggest official benchmark package of the year, but verify before scaling.
Bet on cost per task: DeepSeek V4 Flash 0731 — agentic performance near Opus 4.8 at 1/100th the price.

Three-step action plan

This week: Route agentic coding traffic through DeepSeek V4 Flash 0731 (deepseek/deepseek-v4-flash-0731 on OpenRouter, or DeepSeek API at $0.14/$0.28) and benchmark against your current stack — the 98% cache discount makes repo-context loops almost free.
This month: Evaluate Kimi K3 (AA 57) for your hardest reasoning/multimodal workloads, and watch for Qwen 3.8 Max open weights and first third-party scores — those two events will settle the biggest open question in the comparison.
Re-check in 2–4 weeks: DeepSeek's open-weight release and Qwen 3.8 Max's independent evals will both land; re-run this comparison then, because the gap between official claims and verified reality is exactly where this race will be won.

Sources

Alibaba Qwen official announcement (WeChat, ~July 30, 2026): Qwen3.8-Max specs (2.4T params, 95B active, 1M context), E-Commerce Bench, chip design, oh-my-cli case study — mp.weixin.qq.com/s/9S8VZETppDj_AidiUFrZlw
DeepSeek-V4-Flash-0731 model card (Hugging Face) — agentic benchmark table vs V4 Pro, GLM-5.2, Opus-4.8: huggingface.co/deepseek-ai/DeepSeek-V4-Flash-0731
Artificial Analysis — Intelligence Index scores: DeepSeek V4 Flash 0731 (50), GLM-5.2 (51), Kimi K3 (57), Fable 5 (~60), GPT-5.6 Sol (~59)
Arena (LMArena) Frontend Coding leaderboard — Kimi K3 1,679 Elo; Z.ai Code Arena / Design Arena — GLM 5.2 #1
Moonshot AI Kimi K3 release coverage; OpenRouter model pages; DeepSeek official pricing page ($0.14/$0.28, $0.0028 cached); Trilogy AI StackPerf run (Qwen3.8-Max 80 vs Kimi K3 83)

Last updated: 2026-08-03. All vendor-reported numbers are labeled as claims where third-party verification is pending.

Originally published at: Qwen 3.8 Max vs GLM 5.2 vs Kimi K3 vs DeepSeek V4 Flash (2026): The Complete Frontier Model Comparison

Blox Fruits Dog Blade Value in 2026: Complete Price, Moves & Trading Guide

cz — Mon, 03 Aug 2026 03:43:20 +0000

Blox Fruits Dog Blade Value in 2026: Complete Price, Moves & Trading Guide

🎯 Key Takeaways (TL;DR)

The blox fruits dog blade value is currently estimated at 400M in the community trade guide, with early market ranges of 640M–660M — but confidence is only ~20% since verified trades are still being collected.
The Dog Blade is a Mythical limited sword from the Dog House Event: defeat the event boss, open the Love Letter, and you have a chance to obtain it.
Its moves are M1 (Normal Attack), Z (Spoiled Strike, mastery 175), and X (Tantrum Mode, mastery 375) — but community tests show extremely low damage and a small hitbox for a Mythical.
Because the Dog Blade is a limited, tradable event weapon with 9/10 demand, its trade value can reach multiple permanent fruits — some players report trading it for any perm fruit they want.

目录 (Table of Contents)

What Is the Dog Blade in Blox Fruits?
How to Get the Dog Blade in 2026
Dog Blade Moves & Mastery Requirements
Blox Fruits Dog Blade Value: Full Price Breakdown
Is the Dog Blade Worth Keeping or Trading?
Dog Blade vs Other Limited Swords
How to Trade the Dog Blade Safely
FAQ: Blox Fruits Dog Blade Value Questions
Final Verdict & Next Steps

What Is the Dog Blade in Blox Fruits?

The Dog Blade is a Mythical limited sword introduced in the Secret Doghouse Update, which arrived alongside the Indra Event in July 2026. It is classified as a Weapon / Sword / Limited / Event item, meaning it was only obtainable during its limited-time event window — and that scarcity is exactly what drives the blox fruits dog blade value through the roof.

Unlike permanent swords you can buy with Beli or Robux, the Dog Blade has no dealer price. There is no Beli or Robux vendor that sells it, so the only ways to own one are:

Getting it from the Dog House Event while it was live
Receiving it through player-to-player trading once the item is tradable

💡 Pro Tip
Because the Dog Blade is a limited event item, its availability can change at any time. Always check the Blox Fruits Fandom wiki revision history and current market pages before spending anything on it.

The Dog Blade is often jokingly called the "plastic Dark Blade" by the community because its green energy effects and sword-shaped silhouette resemble the Dark Blade — but with a doghouse-themed twist. Understanding what this weapon actually does is the first step to understanding why the blox fruits dog blade value sits where it does today.

How to Get the Dog Blade in 2026

The Dog Blade was obtainable during the Dog House Event (also called the Doghouse update). Here is the exact step-by-step process the community documented:

📊 Step-by-Step: Dog House Event Obtainment

graph TD
A[Find the Dog House event boss] --> B[Defeat the boss in combat]
B --> C[Receive a Love Letter drop]
C --> D[Open the Love Letter like a chest]
D --> E[Chance to obtain the Dog Blade]

Find the event boss — the Dog House event spawns a special boss encounter that rotates through servers.
Defeat the boss — the boss fight is the core of the event; bring your best fruit and sword loadout.
Collect the Love Letter — defeating the boss drops a Love Letter item.
Open the Love Letter — like opening a chest, the Love Letter is consumed for a chance to drop the Dog Blade.

⚠️ Note
The Love Letter opening is RNG-based — getting the Dog Blade is not guaranteed. Some players opened several letters before their first Dog Blade dropped.

Since the event has already ended, new players can only get the Dog Blade through trading — which is why the blox fruits dog blade value is dominated by trade demand rather than a fixed shop price. A Reddit player who pulled the Dog Blade in the First Sea was told: "You can get any perm fruits with the dog blade. Just keep it until second sea." That single sentence tells you everything about how high the blox fruits dog blade value can climb.

Dog Blade Moves & Mastery Requirements

Before you decide whether the Dog Blade is a fighter or a flex piece, here are the moves as listed on the Blox Fruits Fandom wiki:

Key	Move Name	Mastery Required	Notes
M1	Normal Attack	1	Basic sword swings
Z	Spoiled Strike	175	Community reports green clone summons finishing with an attack
X	Tantrum Mode	375	Transforms you into the doghouse — reported as a non-attack ability

The mastery curve is steep: 375 mastery for Tantrum Mode is an extremely high requirement for any sword, let alone one that players report deals extremely low damage despite being Mythical.

What the Community Says About the Moves

Spoiled Strike (Z) — "Spoiled strike is okay," is the common verdict, with video showcases showing green clone summons before the finishing attack.
Tantrum Mode (X) — one player summed it up bluntly: "tantrum mode does nothing but turn you into the doghouse, not even an attack."
Overall combat rating — the Fandom wiki's cons list calls out "extremely high mastery requirements, extremely low damage... and a small hitbox."

This is a critical nuance for anyone researching the blox fruits dog blade value: the sword's market price is driven by rarity and collectibility, not combat strength. A weapon can be mechanically underwhelming and still command an enormous blox fruits dog blade value because of supply and demand.

Blox Fruits Dog Blade Value: Full Price Breakdown

Now for the number everyone wants. Here is the current market intelligence for the blox fruits dog blade value, sourced from FruitHarbor Market Intelligence and cross-checked against community trade posts:

Metric	Value
Community trade guide value	400M
Early market range estimate	640M – 660M
Trade demand	9/10
Market status	No verified signal yet
Confidence level	~20%
Beli / Robux dealer price	None (limited item)

Why the Price Range Is So Wide

The blox fruits dog blade value currently has a 20% confidence rating because the item is brand new — the market is still collecting completed trades. Two forces are pulling the price in different directions:

Scarcity pressure (raises value): The Dog Blade is a limited Mythical with 9/10 demand. Early collectors are paying premiums, pushing the blox fruits dog blade value toward the 640–660M range.
Unverified data (lowers confidence): With no verified signal and few completed trades on record, the conservative 400M guide price acts as the floor until the market matures.

💡 Pro Tip
If you are trading for a Dog Blade today, treat 400M as the realistic anchor and 640–660M as the seller's asking range. Negotiate between those numbers, and watch for the first verified trades to tighten the range.

The takeaway is simple: the blox fruits dog blade value is high, volatile, and likely to keep climbing while demand stays at 9/10 and supply remains locked to a finished event.

Is the Dog Blade Worth Keeping or Trading?

This is the question behind most blox fruits dog blade value searches, and the honest answer is: it depends on your goal.

Your Goal	Recommendation
Max trade profit	Trade it now or soon — sell into the early-market hype while the blox fruits dog blade value is at 640–660M territory
Permanent fruits	Hold it and use it as trade bait — players confirm it can be traded for any perm fruit you want
Combat / grinding	Not recommended — extremely high mastery and low damage make it a poor PvE weapon
Collection	Keep it — limited Mythicals rarely come back, and the blox fruits dog blade value typically rises after events end

The community consensus from the Reddit threads is clear: if you pulled the Dog Blade early, keep it until the Second Sea and trade it for permanent fruits. That strategy converts the blox fruits dog blade value into the most liquid asset in the game: permanent fruits.

Dog Blade vs Other Limited Swords

How does the Dog Blade compare to other limited Mythicals and event swords? This table puts the blox fruits dog blade value in context:

Sword	Rarity	Event	Trade Value	Combat Usefulness
Dog Blade	Mythical (Limited)	Dog House Event	~400M–660M	Low (small hitbox, low damage)
Dark Blade	Mythical (Limited)	Purchase / Event	High	High (top-tier PvP)
Typical Rare event swords	Rare	Various	Low–Mid	Varies
Typical Legendary swords	Legendary	Permanent	Low	Varies

What this comparison shows is that the blox fruits dog blade value is one of the highest for any event-only sword released in 2026, even though its in-combat performance lags far behind weapons like the Dark Blade. Rarity beats stats in the Blox Fruits trading economy — and the blox fruits dog blade value is a textbook example.

How to Trade the Dog Blade Safely

If you own a Dog Blade — or want to buy one — follow these steps to protect your blox fruits dog blade value:

Check current market pages first (FruitHarbor, trade Discord servers) — the blox fruits dog blade value moves fast.
Confirm the item is tradable — limited event items sometimes have trade restrictions at launch.
Never trade first in a two-step trade — use a trusted middleman or the in-game trade system's simultaneous trade window.
Beware of value inflation scams — with a 20% confidence rating, scammers love quoting the 640–660M number to bait overpayers.
Watch for the first verified trades — the blox fruits dog blade value confidence will jump once real completed trades are recorded.

✅ Best Practice
Treat the trade guide value as a starting point, not a final price. Demand sits at 9/10, which means sellers hold the leverage — but buyers should never pay more than the verified range.

FAQ: Blox Fruits Dog Blade Value Questions

Q: What is the blox fruits dog blade value right now?

A: The current trade guide puts the blox fruits dog blade value at roughly 400M, with early market trades ranging between 640M and 660M. Confidence is low (~20%) because verified completed trades are still being collected, so expect the blox fruits dog blade value to firm up over the coming weeks.

Q: Is the Dog Blade worth permanent fruits?

A: Yes. Multiple community reports confirm the Dog Blade can be traded for any permanent fruit you want. Because of that, the blox fruits dog blade value in perm-fruit terms is effectively one or more permanent fruits.

Q: Why is the blox fruits dog blade value so high if the sword is weak?

A: The blox fruits dog blade value is driven by scarcity, not stats. It is a Mythical limited sword from a finished event with 9/10 trade demand, so supply is fixed while demand stays high. That is the classic recipe for an inflated blox fruits dog blade value.

Q: How do I get the Dog Blade now that the event is over?

A: You can only get it through player trading. The event ended, so the blox fruits dog blade value now reflects pure trade demand. Check trade Discords and market sites, and always verify the seller's reputation.

Q: Is Tantrum Mode a good attack?

A: Based on community testing, Tantrum Mode (X) transforms you into the doghouse and is not reported as an attack. Spoiled Strike (Z) is described as "okay." Neither justifies the 375 mastery requirement in combat — reinforcing that the blox fruits dog blade value is a collectible premium, not a combat premium.

Final Verdict & Next Steps

The blox fruits dog blade value is one of the most interesting market stories of the 2026 Blox Fruits update cycle: a mechanically weak Mythical sword trading like a top-tier asset purely on scarcity and demand. The numbers to remember:

400M — conservative trade guide value
640–660M — early market asking range
9/10 — trade demand
~20% — confidence until verified trades accumulate

Your next steps:

If you own a Dog Blade, decide whether to flip it into the early-market hype or hold it for permanent-fruit trades — both are profitable with the current blox fruits dog blade value.
If you want a Dog Blade, anchor negotiations at 400M, never exceed the 640–660M range, and wait for verified trades before paying premiums.
Keep checking FruitHarbor and the Blox Fruits Fandom wiki — the blox fruits dog blade value will keep updating as more completed trades are recorded, and you do not want to trade on stale numbers.

Sources: FruitHarbor Market Intelligence (fruitharbor.com/en/fruits/dog-blade) and the Blox Fruits Fandom wiki (blox-fruits.fandom.com/wiki/Dog_Blade), cross-referenced with community trade reports. All values are informational estimates and may change without notice.

Originally published at: Blox Fruits Dog Blade Value in 2026: Complete Price, Moves & Trading Guide

Love Meter in 2026: The Complete Guide to Lovemeter.xyz, Free Results, Paid Readings, and the Magic of the Love Oracle

cz — Fri, 31 Jul 2026 02:22:40 +0000

Love Meter in 2026: The Complete Guide to Lovemeter.xyz, Free Results, Paid Readings, and the Magic of the Love Oracle

Looking for a love meter that actually feels honest, fast, and a little bit playful? You are in the right place. Lovemeter.xyz is a free-first compatibility playground built around four tools: Love Meter by Name, Love Meter by Photo, the FLAMES Calculator, and the quietly addictive Love Oracle. This guide walks through how each tool works, what is free, what costs credits, why the Love Oracle hits differently, and how to get the most out of a love meter without taking any number too seriously.

💡 A quick orientation
A love meter is a playful compatibility test, not a science instrument. The best ones give you the same result for the same names, explain the score, and stop short of telling you who to marry. Lovemeter.xyz is built exactly that way.

🎯 Core Takeaways (TL;DR)

Free by default. Every basic love meter reveal — Love Score, Couple Type, Chemistry Score, the FLAMES label, the Love Oracle sign — is free and anonymous. No account needed.
Personal AI readings are paid. A private AI reading costs 100 credits, with one-time packs from $2.99 (100 credits) to $29.99 (1,500 credits). No subscription, no auto-renewal.
The Love Oracle is the wildcard. Unlike the love meter name tools, the Love Oracle uses a six-sign method inspired by Xiao Liu Ren. The sign is calculated, never chosen by AI — which is exactly why it feels magical.

What Is Lovemeter.xyz?
How to Use the Love Meter
The Four Tools Inside the Love Meter
What Is Free vs. What Is Paid
Why the Love Oracle Feels Magical
Love Meter vs. Love Calculator: Are They the Same?
Pricing Breakdown
Privacy, Sharing, and Trust
Frequently Asked Questions
Final Verdict

What Is Lovemeter.xyz?

Lovemeter.xyz is an English-first compatibility entertainment app. Think of it as a love calculator and love meter in one: you type in two names, upload a photo, or ask a question, and the site gives you a free result in a few seconds. If you want the deeper story, you spend credits and unlock a private AI reading.

The product sits on four pillars:

Deterministic core. Name, FLAMES, and Oracle results come from a fixed algorithm, so the same two names always give the same score. That makes the love meter shareable and trustworthy.
AI for the optional layer. Photos use a vision model for the vibe score, and AI readings expand the fixed result into a private essay.
Free first, paid second. The base reveal never costs anything. Reading extras are paid with credits you buy once.
Privacy by design. Photo bytes never sit on the server; only an optional browser cache for 24 hours supports a paid-reading redirect.

How to Use the Love Meter

Using the love meter is intentionally friction-free. Here is the typical flow:

Open the homepage. Go to lovemeter.xyz and pick a tool — Love Meter by Name, Love Meter by Photo, FLAMES Calculator, or Love Oracle.
Type two names (or upload a photo). Both names get normalized (lowercased, sorted), so "Alex & Jamie" and "Jamie & Alex" produce the same Love Meter result.
Hit the reveal button. A short three-step animation sets the mood — "Pairing the names", "Weighing the chemistry", "Sealing your score".
Read the free reveal. You get a Love Score (e.g. 87%), a Chemistry Score, a Couple Type label (e.g. Magnetic Match), and a short summary.
Optionally unlock a reading. If you want a longer, personalized AI interpretation, sign in and spend 100 credits.
Share or download. Copy the link, hit Web Share on mobile, or download a polished PNG card.

✅ Best practice
Treat the result as a conversation starter, not a verdict. The love meter is most fun when both people laugh at the label and then talk about why.

The Four Tools Inside the Love Meter

1. Love Meter by Name

The flagship tool. Two text fields, one animated reveal. Behind the scenes, the love meter normalizes both names, sorts them alphabetically, and seeds a deterministic score. Unicode NFKC normalization means international names work too. The same pair of names always produces the same fixed result — that's the contract.

Example couple types you may see:

Opposites in Orbit — names that land far apart in the number space.
Slow-Burn Pair — patience, small gestures, and time.
Playful Chemistry — the lively middle of the love meter range.
Magnetic Match — a strong result with obvious energy.
Power Couple — the top band, perfect for screenshots.

2. Love Meter by Photo

Upload one couple photo or two separate photos and the love meter returns a visual "vibe" score based on color harmony, composition, style chemistry, and emotional tone. Important boundary: this is the AI layer, so the result may vary slightly between runs. It describes the image — not the people, their loyalty, or their future.

3. FLAMES Calculator

A nostalgic letter-cancellation game turned into a transparent step-by-step result. FLAMES stands for Friends, Love, Affection, Marriage, Enemies, Siblings. The love meter shows every crossed-out letter and every elimination round, so you can verify the result by hand.

4. Love Oracle

The most reflective tool in the suite. Ask one relationship question, choose time mode or three numbers, and receive one of six signs: Peace, Delay, Good News, Conflict, Small Blessing, or Emptiness. The sign is calculated, not chosen by AI — and that is what makes it feel uncanny.

What Is Free vs. What Is Paid

This is the part most people care about, so here is a clean breakdown.

Feature	Free	Paid (100 credits)
Love Meter score, Couple Type, Chemistry Score	✅	—
FLAMES full elimination trace	✅	—
Love Oracle sign + basic prompt	✅	—
Share card (PNG)	✅	—
Public share link with safe summary fields	✅	—
Private AI reading (~450–700 words)	—	✅
Reading sections: strengths, friction, communication, story, things to try	—	✅
Premium share card export	—	✅

The "100 credits" line is consistent across every tool. One reading equals one love meter deep-dive, regardless of which tool produced the fixed result.

⚠️ Note
Sign-in is only required for the paid features and for Love Meter by Photo (because photo processing happens server-side). The classic Love Meter by Name, FLAMES, and Love Oracle work completely anonymously.

Why the Love Oracle Feels Magical

Most "love calculator" sites lean on novelty numbers. The Love Oracle is different, and once you use it, you understand why the community keeps coming back to it.

1. The sign is calculated, not generated. The love meter reads your browser timezone, converts the moment into a lunar month / lunar day / two-hour period, and walks a fixed six-position cycle. AI never picks the sign. That single fact removes the "the AI just told me what I wanted to hear" feeling.

2. There are only six outcomes. Peace, Delay, Good News, Conflict, Small Blessing, Emptiness. Limited options force each sign to carry more weight, which is why one short prompt can suddenly feel personal.

3. The prompt invites action, not prediction. A result like Delay comes with a one-line reflection such as "What changes if you stop forcing the timing?" It hands you a mirror, not a forecast.

4. Time mode and three-number mode give you agency. If you don't want the current moment, you can choose three positive integers. Same three numbers always return the same sign, so you can replay or share without fudging.

5. It is built around healthy boundaries. The love meter explicitly warns against repeating the same question until you get a comforting answer. The product is designed to reduce anxiety, not feed it.

That combination — deterministic, limited, reflective, agency-respecting, anti-addictive — is why long-time users say the Love Oracle is the part of the love meter that actually helps them think.

Love Meter vs. Love Calculator: Are They the Same?

In everyday language, yes. People search for "love meter" and "love calculator" interchangeably. The mechanics are similar: input two names, get a score or label. Where a love meter usually focuses on a numeric compatibility percentage and a couple type (Magnetic Match, Power Couple, etc.), a love calculator sometimes leans on percentage alone or a one-word verdict.

Lovemeter.xyz treats them as the same product family. You will see both terms used in the UI, and the love meter covers everything a classic love calculator does — plus the photo, FLAMES, and Oracle tools that most calculators skip entirely.

Pricing Breakdown

Credits are a one-time purchase. No subscription. No auto-renewal. Stripe and PayPal are both supported.

Pack	Credits	Reading Equivalent	Price	Per-Reading Cost
Starter	100	1	$2.99	$2.99
Standard	500	5	$9.99	~$2.00
Plus	1,000	10	$17.99	~$1.80
Best Value	1,500	15	$29.99	~$2.00

If you only want to try one reading, the Starter pack is the cheapest entry. If you plan to test multiple pairs or want to revisit the love meter across tools, the 1,500-credit pack offers the best flexibility at a lower effective rate.

Privacy, Sharing, and Trust

A few quick notes for anyone worried about putting names into a love calculator:

Photo bytes are not stored server-side. The browser encodes them to base64 and sends them directly for analysis. An optional IndexedDB copy lives for up to 24 hours to support a paid-reading redirect, then expires.
Public result pages are noindex. A shared link won't show up in search engines, so it is safe for casual sharing.
Public share pages hide raw names. The standard card shows the score, the Couple Type, the Chemistry Score, and a short share line — never the raw input names.
Private readings stay private. Only the signed-in owner can read them; the public token only resolves to safe summary fields.

📊 Implementation Flow

graph TD
    A[Open lovemeter.xyz] --> B[Pick a tool]
    B --> C{Anonymous or signed-in?}
    C -- "Name / FLAMES / Oracle" --> D[Enter two names or question]
    C -- "Photo / Paid reading" --> E[Sign in with Google]
    D --> F[Free fixed result]
    E --> F
    F --> G{Happy with the result?}
    G -- Yes --> H[Copy link or download PNG card]
    G -- Want more --> I[Buy a credit pack]
    I --> J[Unlock private AI reading]
    J --> K[Read strengths, friction, story]
    K --> H

Frequently Asked Questions

Q: Is the Love Meter really free?

A: Yes. The Love Meter by Name, FLAMES Calculator, and Love Oracle are free and require no sign-up. You only pay if you want the longer, private AI reading.

Q: Will swapped names change my Love Meter score?

A: No. Names are normalized and sorted before scoring, so "Alex & Jamie" and "Jamie & Alex" produce the same Love Meter result.

Q: How accurate is the Love Meter?

A: Accurate in one sense only: the same two names always produce the same fixed result. It does not measure real feelings, loyalty, or compatibility. Treat the love meter as entertainment.

Q: Why does the Love Oracle feel so specific?

A: Because the sign is calculated from a fixed six-position cycle, not chosen by AI. Combined with only six possible outcomes and a one-line reflective prompt, each result carries more weight than a generic "87%" — which is why people feel seen.

Q: Can the Love Meter predict a relationship?

A: No. None of the tools can predict fidelity, compatibility, or the future. The love meter is built for entertainment and self-reflection.

Q: What payment methods are supported?

A: Stripe (cards) and PayPal. Both are one-time purchases.

Q: Can I get a refund if a reading fails?

A: Yes. If the AI stream fails after a charge, credits are refunded automatically.

Q: Is my question private in the Love Oracle?

A: Yes. The public share page only shows the sign and a safe summary. Your original question is never exposed.

Q: Do I need an account for the photo tool?

A: Yes. Love Meter by Photo requires Google sign-in so the result and any future paid reading can be tied to one user. Photo bytes still never persist on the server.

Q: Is this the same as a love calculator?

A: Functionally, yes. Lovemeter.xyz is a love meter and love calculator in one, with two extra tools (FLAMES, Oracle) most calculators don't include.

Final Verdict

If you want a love meter that respects your time, your privacy, and your intelligence, lovemeter.xyz is the one to try first. Every base tool is free, the scores are deterministic so they are shareable, the photo tool is visually delightful without overreaching, and the Love Oracle is the rare reflective product that actually leaves you thinking instead of scrolling.

The pricing is honest: one-time credits, no subscription, refund on failure. The privacy story is clear: no photo bytes on the server, noindex public pages, raw names never shown. And the entertainment boundary is repeated everywhere, so no one mistakes a percentage for a prognosis.

Next steps:

Visit lovemeter.xyz and try the Love Meter by Name with a partner, friend, or two fictional characters.
Open the Love Oracle and ask one genuine question in time mode.
If the result makes you smile, share the card. If it makes you think, unlock a reading.

Either way, you just used a love meter the way it was meant to be used — as a mirror, not a fortune cookie.

Originally published at: Love Meter in 2026: The Complete Guide to Lovemeter.xyz, Free Results, Paid Readings, and the Magic of the Love Oracle

Unlimited OCR (2026): Baidu's One-Shot Long-Horizon Document Parser That Beats DeepSeek OCR

cz — Thu, 23 Jul 2026 06:48:22 +0000

Unlimited OCR (2026): Baidu's One-Shot Long-Horizon Document Parser That Beats DeepSeek OCR

🎯 Core Takeaways (TL;DR)

If you need to transcribe entire books, multi-page contracts, or hundred-page PDFs in a single inference pass, unlimited ocr is the new state of the art. Here's the short version:

Unlimited ocr is Baidu Inc.'s open-source end-to-end OCR model released June 22, 2026, that uses a novel Reference Sliding Window Attention (R-SWA) decoder to keep the KV cache constant during long-sequence generation.
On OmniDocBench v1.5, unlimited ocr scores 93.23% overall, beating the DeepSeek OCR baseline by +6.22 points, and on v1.6 it reaches 93.92% — end-to-end SOTA among open models.
The model ships with MIT-licensed weights on Hugging Face (baidu/Unlimited-OCR) and full inference code (Transformers + bundled SGLang wheel) at github.com/baidu/Unlimited-OCR. In its first 24 hours it collected 1.8k+ GitHub stars.
Two inference configs are exposed: gundam (640, crop on, fastest) and base (1024, crop off, full-fidelity multi-page). Both run with max_length=32K and no_repeat_ngram_size=35.
Unlimited ocr is 35% faster than DeepSeek OCR at 6,000 generated tokens (TPS 7,847 vs 5,823), and the gap widens as the document grows — making unlimited ocr the most efficient long-horizon OCR stack you can self-host today.

✅ Best Practice: Use unlimited ocr in base mode with image_size=1024 for any PDF longer than a few pages. Reach for gundam only when you need high-throughput single-image inference and can tolerate aggressive cropping.

📑 Table of Contents

What Is Unlimited OCR?
Why Long-Horizon OCR Matters in 2026
How Unlimited OCR Works: R-SWA and DeepEncoder
Side-by-Side Specification Table
Benchmark Showdown on OmniDocBench
Long-Horizon Performance: 2 to 40+ Pages
Throughput and Efficiency vs DeepSeek OCR
How to Run Unlimited OCR Locally
Production Deployment with SGLang
Comparison with Alternatives
Frequently Asked Questions
Final Verdict and Next Steps

What Is Unlimited OCR? {#what-is-unlimited-ocr}

Unlimited ocr (full project name Unlimited OCR Works — Welcome the Era of One-shot Long-horizon Parsing) is an end-to-end multimodal OCR model released by Baidu Inc. on June 22, 2026, with the technical report published the same day as arXiv paper 2606.23050. The project's defining claim is simple but unprecedented: unlimited ocr can transcribe dozens of pages of a document in a single forward pass, under a standard 32K context window, with no per-page chunking or output stitching.

Unlike pipeline OCR stacks (PaddleOCR, MonkeyOCR, Dolphin) that chain a detection model with multiple recognition operators, unlimited ocr is a fully end-to-end vision-language model built on top of DeepSeek OCR. The encoder is the same DeepEncoder used by DeepSeek OCR — a SAM-ViT + CLIP-ViT cascade with 16× token compression that maps a 1024×1024 page image to just 256 visual tokens. The decoder is an MoE LLM (3B total parameters, 500M activated) where every standard attention layer has been replaced with Reference Sliding Window Attention (R-SWA).

The headline number behind unlimited ocr: it converts the normally explosive, sequence-length-scaling KV cache into a bounded constant KV cache of size L_m + n, where L_m is the prefix (visual + prompt) length and n is the decode-window width (default 128). This is the trick that lets unlimited ocr parse a 40-page book without ever needing to spill to disk or restart attention.

Attribute	Value
Model name	Unlimited OCR (a.k.a. Unlimited OCR Works / UOW)
Publisher	Baidu Inc.
Release date	June 22, 2026
License	MIT (open weights, commercial use OK)
Hugging Face	`baidu/Unlimited-OCR`
GitHub	`github.com/baidu/Unlimited-OCR`
ModelScope	Live mirror
Architecture	DeepEncoder (SAM-ViT + CLIP-ViT, 16× compression) + MoE LLM with R-SWA
Total parameters	3B
Activated parameters	500M
Context window	32K tokens (training and inference)
Inference modes	`gundam` (640, crop on), `base` (1024, crop off)
GitHub stars in 24h	1,800+

Why Long-Horizon OCR Matters in 2026 {#why-it-matters}

Every modern document-AI pipeline — RAG over enterprise PDFs, agentic compliance review, scholarly search, financial extraction — eventually hits the same wall: you cannot feed a 200-page document into a model that can only see one page at a time.

Before unlimited ocr, the standard pattern was:

Split the PDF into pages.
OCR each page independently.
Stitch the outputs together, hoping the table that spans pages 4–5 didn't break, that the footnote anchor on page 12 didn't lose its target, and that the section header on page 30 didn't bleed into the wrong chapter.

This stitching step is where errors compound. It's an engineering workaround, not intelligence. Unlimited ocr replaces it with one forward pass that treats the whole document as a single sequence — exactly how a human sits down to transcribe a book.

Three forces made 2026 the year this finally shipped:

Visual compression is now extreme. DeepEncoder's 16× token compression means a 40-page document takes only ~10K visual tokens — small enough to fit in 32K context once you add room for the output.
KV cache economics finally caught up. R-SWA bounds the decode-side cache to a constant window, which means unlimited ocr's TPS stays roughly flat from page 1 to page 40+.
Open weights beat closed APIs on price. Unlimited ocr is MIT-licensed, runnable on a single A800/H100 box, and avoids per-page API taxes from GPT-4o or Gemini.

If your product's moat is "we read documents better than the other guy," unlimited ocr is the new baseline.

💡 Pro Tip: The hardest part of document AI is no longer "read this page accurately." It's "read 200 pages as one document." Unlimited ocr is the first open model that genuinely solves the second problem.

How Unlimited OCR Works: R-SWA and DeepEncoder {#how-it-works}

DeepEncoder: visual compression that keeps the KV cache small

Unlimited ocr inherits DeepEncoder from DeepSeek OCR. It's a two-stage ViT cascade:

Stage 1 (SAM-ViT): window attention only, processes the raw image tokens at full resolution.
Stage 2 (CLIP-ViT): global attention, processes the already-compressed tokens.

A 16× compression layer between the two stages means a 1024×1024 PDF page collapses to 256 tokens. Critically, these visual tokens are encoded once and stay static through the entire decode — they don't undergo state transitions. That's what makes R-SWA viable: the reference side never grows.

Reference Sliding Window Attention (R-SWA): the core innovation

Standard Multi-Head Attention has a KV cache that grows linearly with the number of generated tokens. For a 100K-token decode, that's a memory and latency disaster.

R-SWA replaces it with a two-segment attention window:

Reference segment (size L_m) — all visual tokens plus the prompt. Every decoding token attends to all of them, every step. This segment is fixed; it does not grow.
Decode sliding window (size n=128) — only the most recent 128 generated tokens. This window slides causally.

Formally, for token t, the attention set is:

𝒩(t) = 𝒫 ∪ 𝒟_n(t)
𝒫 = {1, …, L_m}                 ← reference (visual + prompt)
𝒟_n(t) = {j | max(L_m+1, L_m+t-n) ≤ j ≤ L_m+t-1}   ← causal sliding window

The KV cache becomes C_R-SWA(T) = L_m + min(n, T) ≤ L_m + n — a constant upper bound, instead of the standard L_m + T that grows without limit.

This is more than a memory trick. It's a deliberate model of human parsing working memory: when you transcribe a book, you don't re-read everything you've written — you glance at the source page and a few characters of context. R-SWA is the architectural analog.

Training details that matter

Starting point: the released DeepSeek OCR checkpoint.
Data: ~2M document OCR samples (9:1 single-page : multi-page), all packed to 32K tokens. Multi-page samples are synthesized by concatenating 2–50 single pages with a <page> separator.
Hardware: 8×16 A800 GPUs.
Schedule: 4,000 steps, global batch size 256, AdamW with cosine annealing, LR 1e-4.
Trick: DeepEncoder is frozen during continue-training; only the LLM decoder's attention layers are replaced with R-SWA and trained. DeepEP with EP=4 provides expert parallelism.

⚠️ Watch out: Unlimited ocr's "unlimited" is bounded by the 32K context. If you prefill 100+ pages, you'll hit the prefix budget before you hit the decode budget. The paper notes a 128K training run is on the roadmap.

Side-by-Side Specification Table {#spec-table}

Specification	Unlimited OCR (Baidu)	DeepSeek OCR (baseline)	MinerU 2.5	Mistral OCR 4
Publisher	Baidu Inc.	DeepSeek AI	OpenDataLab	Mistral AI
Release date	June 22, 2026	2025	2026	June 23, 2026
License	MIT (open)	Open weights	Apache 2.0	Proprietary (self-host enterprise)
Architecture	DeepEncoder + MoE LLM with R-SWA	DeepEncoder + MoE LLM with MHA	Pipeline + VLM	Managed API
Total / activated params	3B / 500M	3B / 500M	~0.9B–12B	n/a
Visual compression	16×	16×	varies	n/a
Max decode length	32K (constant KV)	grows linearly	per-page	per-document API
Multi-page in one pass	✅ Yes (40+ pages tested)	❌ page-by-page	Limited	✅ via API
PDF-native workflow	✅ PyMuPDF helper in repo	❌ manual	✅	✅ native
Bounding boxes / block types	❌	❌	✅	✅
Inference engines	Transformers, SGLang	Transformers, vLLM	Pipeline	API only
OmniDocBench v1.5 overall	93.23%	87.01%	85.56% (v2)	n/a
OmniDocBench v1.6 overall	93.92%	90.25% (DS-OCR 2)	n/a	n/a

Benchmark Showdown on OmniDocBench {#benchmarks}

OmniDocBench v1.5 (end-to-end models)

Model	Size	Overall ↑	Text Edit ↓	Formula CDM ↑	Table TEDS ↑	Table TEDS-S ↑	Read-Order Edit ↓
Unlimited OCR	3B-A0.5B	93.23	0.038	92.61	90.93	94.07	0.045
DeepSeek-OCR 2	3B-A0.5B	89.17	0.049	86.85	85.60	90.06	0.060
Qwen3-VL	235B	89.15	0.069	88.14	86.21	90.55	0.068
OCRVerse	4B	88.56	0.058	86.91	84.55	88.45	0.071
dots.ocr	3B	88.41	0.048	83.22	86.78	90.62	0.053
Gemini-2.5 Pro	—	88.03	0.075	85.82	85.71	90.29	0.097
Qwen2.5-VL	72B	87.02	0.094	88.27	82.15	86.22	0.102
DeepSeek-OCR (baseline)	3B-A0.5B	87.01	0.073	83.37	84.97	88.80	0.086
InternVL3.5	241B	82.67	0.142	87.23	75.00	81.28	0.125

Reading: Unlimited ocr's 93.23% is +6.22 above the DeepSeek OCR baseline it's built on, and ahead of every published end-to-end model on v1.5 — including Gemini-2.5 Pro and Qwen3-VL-235B.

OmniDocBench v1.6

Model	Size	Overall ↑
Unlimited OCR	3B-A0.5B	93.92
Qianfan-OCR	4B	93.90
Logics-Parsing-v2	4B	93.33
FireRed-OCR	2B	93.26
dots.ocr	3B	90.77
DeepSeek-OCR 2	3B-A0.5B	90.25
HunyuanOCR	1B	89.95

Unlimited ocr posts the highest single-page overall score on v1.6 while still being one of the smallest models in the table — a strong signal that R-SWA is doing real architectural work, not just absorbing capacity.

Subcategory study (OmniDocBench v1.5)

The paper also reports per-document-type edit distance. Unlimited ocr wins or ties the text edit distance on every category (PPT, academic papers, books, colorful textbooks, exam papers, magazines, newspapers, notes, research reports) compared to both DeepSeek OCR and DeepSeek OCR 2. For complex layouts — newspapers, colorful textbooks, magazines — the improvement is largest, suggesting R-SWA's bounded attention is actually helpful for layout-heavy pages, not just a constraint.

Long-Horizon Performance: 2 to 40+ Pages {#long-horizon}

This is the experiment that justifies the name unlimited ocr. The authors built an in-house benchmark of novels, papers, and long documents bucketed by page count: 2, 5, 10, 15, 20, and 40+ pages, at least ten documents per bucket.

Pages	Distinct-20 ↑	Distinct-35 ↑	Edit Distance ↓
2	99.76%	99.87%	0.0362
5	99.78%	99.98%	0.0452
10	97.49%	99.83%	0.0526
15	99.92%	99.99%	0.0787
20	98.73%	99.89%	0.0572
40+	96.08%	96.90%	0.1069

Even at 40+ pages, unlimited ocr keeps a 97% Distinct-35 (i.e., it almost never loops on an n-gram it already produced) and a sub-0.11 edit distance. The authors' failure analysis found that most residual errors come from small text in low-resolution PDFs, not from R-SWA losing direction — a fixable problem, not an architectural one.

✅ Best Practice: If your PDF has very small body text (footnotes, fine print, dense tables), upscale to 200–300 DPI before feeding it to unlimited ocr. The "Base" encoder at 1024×1024 with R-SWA still produces the best long-horizon results.

Throughput and Efficiency vs DeepSeek OCR {#throughput}

Unlimited ocr was measured at identical settings to DeepSeek OCR, prefill length 10, varying generated length.

Output tokens	DeepSeek OCR TPS	Unlimited OCR TPS	Speedup
256	7,229	7,229	~1.0×
512	7,468	7,714	1.03×
1,024	7,422	7,840	1.06×
2,048	7,166	7,881	1.10×
3,072	6,790	7,881	1.16×
4,096	6,430	7,905	1.23×
6,144	5,822	7,847	1.35×

At 4K tokens unlimited ocr is already 23% faster, and at 6K tokens the gap widens to 35%. Because R-SWA bounds the KV cache, the per-step cost stays flat; DeepSeek OCR's TPS keeps degrading because every step recomputes attention over an ever-growing full history.

On the OmniDocBench v1.5 inference run (256 concurrency, 512-batch TPS), unlimited ocr posts 5,580 TPS vs DeepSeek OCR's 4,951 TPS — a 12.7% throughput gain even on short documents. On longer documents the gap compounds.

How to Run Unlimited OCR Locally {#how-to-run}

Step 1 — Install dependencies

pip install torch==2.10.0 torchvision==0.25.0 transformers==4.57.1
pip install Pillow matplotlib einops addict easydict pymupdf psutil

Step 2 — Single image (gundam mode)

import torch
from transformers import AutoModel, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "baidu/Unlimited-OCR", trust_remote_code=True
)
model = AutoModel.from_pretrained(
    "baidu/Unlimited-OCR",
    trust_remote_code=True,
    use_safetensors=True,
    torch_dtype=torch.bfloat16,
).eval().cuda()

model.infer(
    tokenizer,
    prompt="<image>document parsing.",
    image_file="your_image.jpg",
    output_path="./output",
    base_size=1024,        # encoded page size
    crop_mode=True,        # gundam config
    max_length=32768,
    no_repeat_ngram_size=35,
    ngram_window=128,
    save_results=True,
)

Step 3 — Multi-page PDF (base mode)

import torch, fitz, tempfile, os
from transformers import AutoModel, AutoTokenizer

def pdf_to_images(pdf_path, dpi=300):
    doc = fitz.open(pdf_path)
    tmp_dir = tempfile.mkdtemp(prefix="pdf_ocr_")
    mat = fitz.Matrix(dpi / 72, dpi / 72)
    paths = []
    for i, page in enumerate(doc):
        out = os.path.join(tmp_dir, f"page_{i+1:04d}.png")
        page.get_pixmap(matrix=mat).save(out)
        paths.append(out)
    doc.close()
    return paths

tokenizer = AutoTokenizer.from_pretrained(
    "baidu/Unlimited-OCR", trust_remote_code=True
)
model = AutoModel.from_pretrained(
    "baidu/Unlimited-OCR", trust_remote_code=True,
    torch_dtype=torch.bfloat16
).eval().cuda()

model.infer_multi(
    tokenizer,
    prompt="<image>Multi page parsing.",
    image_files=pdf_to_images("your_doc.pdf", dpi=300),
    output_path="./output",
    image_size=1024,       # base mode
    max_length=32768,
    no_repeat_ngram_size=35,
    ngram_window=1024,
    save_results=True,
)

💡 Pro Tip: no_repeat_ngram_size=35 and ngram_window are the repetition-suppression knobs inherited from DeepSeek OCR. They stop the model from looping on dense repeated patterns (table headers, footnotes, page numbers). For multi-page documents, raise ngram_window to 1024 so the suppression window is wider than any legitimate repetition.

Production Deployment with SGLang {#deployment}

For production traffic, the repo bundles an SGLang wheel with an OpenAI-compatible API server.

python -m sglang.launch_server \
  --model baidu/Unlimited-OCR \
  --served-model-name Unlimited-OCR \
  --attention-backend fa3 \
  --context-length 32768 \
  --enable-custom-logit-processor \
  --host 0.0.0.0 \
  --port 10000

Then call it with the standard multimodal message format:

import openai
client = openai.OpenAI(base_url="http://localhost:10000/v1", api_key="EMPTY")

resp = client.chat.completions.create(
    model="Unlimited-OCR",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "<image>document parsing."},
            {"type": "image_url", "image_url": {"url": "file://page1.png"}},
            {"type": "image_url", "image_url": {"url": "file://page2.png"}},
            # ... up to dozens of pages
        ],
    }],
    stream=True,
    extra_body={
        "images_config": {"image_mode": "base"},
        "custom_params": {"ngram_size": 35, "window_size": 1024},
    },
)

Batch jobs with `infer.py`

# Image directory
python infer.py \
  --image_dir ./examples/images \
  --output_dir ./outputs \
  --concurrency 8 \
  --image_mode gundam

# PDF
python infer.py \
  --pdf ./examples/document.pdf \
  --output_dir ./outputs \
  --concurrency 8 \
  --image_mode base

The --concurrency flag controls how many pages are processed in parallel — useful for ingesting thousands of PDFs overnight.

Comparison with Alternatives {#alternatives}

Model	Multi-page in one pass	Open weights	PDF native	Context	Bounding boxes	Best for
Unlimited ocr	✅ `infer_multi`	✅ MIT	✅ PyMuPDF helper	32K (constant KV)	❌	Long-horizon books, dense docs
Mistral OCR 4	per-document API	Enterprise self-host	✅	API	✅	Managed Document AI, typed blocks
DeepSeek-OCR	single image	✅	❌	shorter	❌	Quick single-page extraction
DeepSeek-OCR 2	limited	✅	❌	longer	❌	Higher single-page fidelity
MinerU 3.4	via pipeline	✅	✅	hybrid	✅	Full multi-backend production stack
GPT-4o Vision	page-by-page API	❌	via preprocessing	API limit	partial	When you already use OpenAI

The unlimited ocr sweet spot: you need to ingest entire PDFs in one shot, you want self-hosted open weights, and you can survive without bounding-box outputs (use it as a Markdown extraction step, then add layout logic downstream if needed).

🤔 Frequently Asked Questions {#faq}

Q: What is unlimited ocr?

Unlimited ocr is Baidu Inc.'s open-source end-to-end OCR model released June 22, 2026. It introduces Reference Sliding Window Attention (R-SWA) in the decoder, which keeps the KV cache constant during generation. The result is a model that can transcribe dozens of pages of a document in a single forward pass under a standard 32K context window, without chunking or output stitching.

Q: How is unlimited ocr different from DeepSeek OCR?

Both share the same DeepEncoder visual front end, but unlimited ocr replaces every Multi-Head Attention layer in the decoder with R-SWA. DeepSeek OCR's KV cache grows linearly with output length; unlimited ocr's is bounded by a constant window. On OmniDocBench v1.5, unlimited ocr scores 93.23% vs DeepSeek OCR's 87.01% — a +6.22 absolute gain.

Q: Is unlimited ocr really open source?

Yes. The weights are MIT-licensed on Hugging Face (baidu/Unlimited-OCR) and ModelScope, and the full inference code is at github.com/baidu/Unlimited-OCR. MIT permits commercial use, modification, and redistribution.

Q: How many pages can unlimited ocr handle in one forward pass?

In the paper's long-horizon evaluation, unlimited ocr was tested up to 40+ pages in a single call, with 96.08% Distinct-20 and 96.90% Distinct-35 — meaning the model almost never loops on previously generated text. Beyond that, you hit the 32K context budget; the authors flag a 128K training run as the next step.

Q: How do I run unlimited ocr locally?

Install PyTorch 2.10.0 + Transformers 4.57.1, then AutoModel.from_pretrained("baidu/Unlimited-OCR", trust_remote_code=True, torch_dtype=torch.bfloat16).cuda(). For single images use model.infer(...) with crop_mode=True (gundam). For PDFs use model.infer_multi(...) with image_size=1024 (base) and a PyMuPDF helper that renders pages at 300 DPI.

Q: Can I deploy unlimited ocr as an API server?

Yes. The repository bundles an SGLang wheel with python -m sglang.launch_server --model baidu/Unlimited-OCR --attention-backend fa3 --context-length 32768 --enable-custom-logit-processor. It exposes an OpenAI-compatible endpoint at /v1/chat/completions with streaming and multimodal message support.

Q: What are gundam and base modes?

Gundam is the high-throughput single-image config: 640 resolution with cropping enabled, fastest tokens-per-second for one-shot images. Base is the full-fidelity multi-page config: 1024 resolution without cropping, the right choice for PDFs and dense layouts. The infer.py batch script exposes both via --image_mode.

Q: Does unlimited ocr replace Mistral OCR 4 or MinerU 3.4?

It depends on what you need. Unlimited ocr wins on single-pass multi-page parsing and open-weight self-hosting. Mistral OCR 4 wins on managed API, bounding boxes, and typed block classification. MinerU 3.4 wins on full production pipelines (hybrid backends, VLM routing, multi-GPU). In practice, many teams will route Mistral for extraction-with-layout and unlimited ocr for raw long-document ingestion.

Q: Why is it called "unlimited" if the context is only 32K?

The name refers to unlimited output length, not unlimited input. Because R-SWA bounds the decode-side KV cache to L_m + n regardless of how long the output grows, unlimited ocr can in principle keep generating until it hits the context window. The remaining bottleneck is the prefix budget — but with DeepEncoder's 16× compression, a 32K context comfortably fits a 30+ page document. The authors' roadmap explicitly targets 128K contexts and a "prefill pool" that simulates flipping through pages of a book.

Final Verdict and Next Steps {#verdict}

Unlimited ocr is the first open-weight model that genuinely changes the document-AI calculus in 2026. It is not the smallest, the fastest at short contexts, or the cheapest to run on a single image — but it is the only one that lets you point it at a 40-page PDF and walk away.

Three-step action plan

Today: pip install transformers==4.57.1 pymupdf and run model.infer_multi(...) on a real 20+ page PDF from your corpus. Compare the output against your current page-by-page pipeline and measure both edit distance and the absence of stitching artifacts.
This week: Stand up the bundled SGLang server behind your existing document ingestion endpoint. Use images_config.image_mode=base for PDFs, gundam for thumbnails and previews.
Next month: Evaluate unlimited ocr against Mistral OCR 4 for your top three document workflows. Where you need bounding boxes or block types, route to Mistral; where you need raw long-document transcription, route to unlimited ocr.

Bottom line

✅ In 2026, the document-AI stack that wins is the one that can ingest an entire document as one sequence, not a stitched-together sequence of pages. Unlimited ocr is the first open-weight model that makes that practical — 93%+ on OmniDocBench, 35% faster than DeepSeek OCR at long outputs, MIT-licensed, runnable on a single A800/H100 box. If you're building RAG, agentic compliance review, scholarly search, or financial extraction, this is the new baseline.

Sources & further reading

Baidu — Unlimited-OCR on Hugging Face
Baidu — Unlimited-OCR on GitHub
Baidu — arXiv paper 2606.23050 — Unlimited OCR Works: Welcome the Era of One-shot Long-horizon Parsing
vLLM Project — Unlimited-OCR recipe
DeepSeek OCR baseline — Wei et al., 2025
OmniDocBench v1.5 / v1.6 — Ouyang et al., 2025

Last updated: 2026-07-23.

Unlimited OCR

Originally published at: Unlimited OCR (2026): Baidu's One-Shot Long-Horizon Document Parser That Beats DeepSeek OCR