What is dots3-note and who developed it?

dots3-note preview is an open-weight 280B multimodal Mixture-of-Experts (MoE) foundation model developed by dots studio, the artificial intelligence research lab of RedNote (Xiaohongshu). Released under the Apache 2.0 license, it operates with 16B active parameters per token, natively ingests text, images, video, and audio, and supports a native 512K context window.

What is the core breakthrough of the TEMPO reinforcement learning framework?

TEMPO (Test-time-scaled Value Estimation with Macro-step Policy Optimization) is a reinforcement learning architecture specifically formulated to solve the credit assignment collapse in long-horizon autonomous tasks. Rather than calculating advantage functions over hundreds of noisy individual tool calls, TEMPO aggregates execution into discrete macro-steps, periodically toggling the model from an actor into an evaluator (critic) that utilizes test-time compute to estimate remaining trajectory returns.

Why do traditional reinforcement learning algorithms (like PPO, DPO, or GRPO) fail on multi-hour agent workflows?

Standard policy optimization relies on Monte Carlo returns or monolithic value heads where the variance of the gradient estimator scales proportionally with trajectory length T. In agent workflows exceeding 50 to 100 tool interactions, sparse terminal feedback causes credit assignment to collapse: an error in step 87 penalizes early correct steps, or accidental success rewards catastrophic intermediate hallucinations.

How does Actor-Critic switching operate under TEMPO?

At the conclusion of each macro-step boundary, a specialized control token toggles the model from generation (Actor mode) to verification (Critic mode). In Critic mode, the model allocates test-time reasoning tokens to simulate prospective rollouts and verify intermediate state invariants against contract specifications, producing a dense, highly calibrated advantage signal without requiring an external reward model.

What are VibeSearchBench and VibeLifeBench?

VibeSearchBench and VibeLifeBench are two dynamic evaluation environments released alongside dots3-note by dots studio. They benchmark models on open-ended, real-world, long-horizon objectives (such as multi-day logistical coordination, complex full-stack codebase refactors, and research synthesis) where tasks lack deterministic single-token answers.

How is dots3-note served efficiently in production inference stacks like vLLM and SGLang?

With 280B total parameters and 16B active parameters per token, dots3-note is deployed using hybrid Tensor Parallelism and Expert Parallelism (TP4-EP2 or TP8). In vLLM and SGLang, radix attention and prefix caching ensure that the frequent switching between actor execution and critic verification incurs minimal Time-to-First-Token (TTFT) latency overhead.

Inside dots3-note & TEMPO: RedNote's 280B Multimodal MoE and How Macro-Step Policy Optimization Fixes Long-Horizon Agent Degradation

Simplified Overview (ELI5)

Written by Abrar Akhunji

Have you ever tried to assemble a 2,000-piece Lego castle without looking at the instruction booklet after step one?

For the first five minutes, you feel like a genius. By step 40, you’ve put three red pillars in the wrong room. By step 120, your castle roof caves in, and you have no idea which brick caused the disaster.

This is the exact nightmare confronting today's autonomous AI coding agents and assistants.

The Silent Crisis of AI Agents: "Trajectory Drift"

When you ask modern AI models (like Claude, GPT-4o, or DeepSeek) to perform a quick task—such as writing a regex or drafting an email—they shine. But when you ask them to manage an autonomous, 3-hour software migration involving 80 terminal commands, 14 API calls, and 25 file edits, they almost always crash and burn.

Why? Because of Credit Assignment Collapse:

In standard AI training, the model only gets a "score" at the very end (did the whole task succeed or fail?).
If an agent executes 90 great actions and makes one fatal typo on step 91, the training algorithm accidentally punishes all 90 brilliant actions.
Conversely, if an agent bumbles around randomly and gets lucky at step 100, the algorithm rewards its terrible intermediate hallucinations!

Over time, this makes long-horizon agents jittery, fragile, and prone to endless hallucination loops.

Enter dots3-note and the TEMPO Framework

In an industry-shaking release, dots studio (the frontier AI research laboratory at RedNote/Xiaohongshu) open-sourced dots3-note preview under the Apache 2.0 license.

It is a massive 280-Billion parameter multimodal Mixture-of-Experts (MoE) model that runs with the speed and efficiency of a lean 16-Billion active parameter engine. It natively hears audio, sees images and video, reads text, and handles an enormous 512,000 token context window.

But the real crown jewel isn't just its raw size—it is TEMPO (Test-time-scaled Value Estimation with Macro-step Policy Optimization).

Standard Agent: Blind Sprinting until Crash
[ Step 1 ] ──> [ Step 2 ] ──> [ ... ] ──> [ Step 87: Bug! ] ──> [ Step 120: Total Failure ]
(No checkpoints, no reflection, impossible credit assignment)

TEMPO Agent: Structured Macro-Steps with Actor-Critic Checkpoints
[ Macro-Step 1: Scoping ] ──> [ CRITIC PAUSE: Test-Time Value Check ] ── (Pass)
                                              │
[ Macro-Step 2: Core Coding ] ──> [ CRITIC PAUSE: Test-Time Verification ] ── (Catch bug & self-correct)
                                              │
[ Macro-Step 3: Verification ] ──> [ Autonomous Goal Delivery ]

The Magic of Actor-Critic Switching

Instead of running blindly for 200 steps, TEMPO breaks complex missions into Macro-Steps (milestones).

At the end of every milestone:

The Model Freezes Its Hands (Actor Phase Ends): The agent stops executing commands.
The Model Puts on Its Glasses (Critic Phase Begins): It temporarily morphs into a harsh, objective code reviewer.
Test-Time "What-If" Reasoning: It spends extra thinking tokens simulating future outcomes: "If we proceed down this path, will the build succeed? Are we deviating from the user's constraints?"
Course Correction: If it detects drift, it adjusts its strategy and updates its internal memory before making the next move.

The result? An agent that can execute hundreds of consecutive actions over hours without losing its mind or wandering into hallucination traps.

Let’s dive into the tensor mathematics, reinforcement learning loss functions, PyTorch architectures, and production serving benchmarks that power this breakthrough.

The 5-Stage TEMPO Autonomous Execution Lifecycle

Invariant Contract & Sub-Goal Scoping: The agent decomposes an incoming multi-hour engineering objective into ordered macro-step contracts, establishing clear deterministic invariants for each milestone.
High-Throughput Actor Execution: Operating in Actor mode, dots3-note generates tool invocations and commands with high tokens/sec generation until the macro-step milestone boundary is reached.
Actor-to-Critic Phase Transition: The agent inserts [CRITIC_EVAL_ENTER], halting outward environment commands and switching internal attention heads into reflective assessment mode.
Test-Time Value Rollout Estimation: Allocating test-time reasoning tokens, the model samples prospective solution branches to estimate expected trajectory return V_TEMPO(s_k) via contract verification.
Macro-Advantage Calibration & Memory Pruning: The computed macro-advantage is recorded, stale intermediate context is purged from the KV cache, and the agent resumes Actor mode for the next milestone.

Section 6: Empirical Benchmarks & Systems Evaluation

To evaluate the real-world operational impact of dots3-note and TEMPO, dots studio introduced two benchmark suites alongside standard frontier metrics:

VibeSearchBench: Tests open-ended, multi-source research synthesis requiring 40+ chained search queries, document cross-referencing, and contradictory evidence resolution.
VibeLifeBench: Measures long-horizon, real-life planning (e.g., 7-day logistical schedules, wedding vendor coordination, and infrastructure capacity rebalancing) where no single deterministic string matches ground truth.
SWE-Bench Verified (Long-Horizon Patching): Measures full repository bug resolution where initial reproduction scripts require more than 60 bash and git operations.

The comparative performance across dots3-note + TEMPO, Claude 3.5 Sonnet, GPT-4o, and DeepSeek-R1 is illustrated below:

Long-Horizon Agent Performance & Stability Benchmarks (October 2026)

Comparative evaluation across multi-step success rate, trajectory drift resistance, real-world benchmark performance, and active compute overhead.

metric	dots3-note + TEMPO (280B/16B)	Claude 3.5 Sonnet (Dense/Prop)	DeepSeek-R1 (671B/37B MoE)	GPT-4o (Dense/Prop)
Success Rate @ 100+ Steps (%)	78.4	64.2	71	52.8
VibeSearchBench Score (%)	84.6	79.1	81.5	72.3
VibeLifeBench Planning (%)	76.9	68.4	69.2	58
SWE-Bench Verified (%)	54.8	51.4	53.2	41.2
Active GFLOPs / Token	32.4	128	74	115

Benchmark Analysis

Unprecedented Long-Horizon Retention: At over 100 sequential environment steps, dots3-note + TEMPO sustains a 78.4% success rate, outperforming Claude 3.5 Sonnet (64.2%) and DeepSeek-R1 (71.0%). Standard models experience exponential trajectory drift as unverified assumptions compound.
Compute Efficiency: Because only 16.2B active parameters fire during execution, dots3-note expends just 32.4 GFLOPs per token, less than half the active compute of DeepSeek-R1 (74.0 GFLOPs) and one-fourth of dense frontier models.
Open-Weight Autonomy: For the first time under an Apache 2.0 license, enterprise engineering teams can deploy an on-premises agent engine capable of autonomous multi-hour operations without relying on proprietary closed APIs.

Section 7: Serving & Production Orchestration in vLLM / SGLang

Deploying dots3-note in production requires handling both the 280B model footprint and the dynamic switching between Actor and Critic modes.

Cluster Topologies

Dual-Node 8x H100 (TP4-EP2 or TP8): Fits the full 280B weights in FP8 / BF16 with ample headroom for the 512K context KV-cache.
Single-Node 8x H100 with MXFP4 Quantization: Utilizing native microscaling 4-bit floating point for the expert weights drops memory requirements to under 160 GB, allowing full serving on a single 8-GPU node.

Mitigating Mode-Switch Latency via Prefix Radix Caching

When dots3-note switches into Critic mode at a macro-step boundary, naive inference engines would suffer from massive Time-to-First-Token (TTFT) penalties re-ingesting the full episode history.

In vLLM and SGLang, this is solved through Radix Tree Prefix Caching:

# Production launch command for dots3-note in vLLM
python3 -m vllm.entrypoints.openai.api_server \
  --model dots-studio/dots3-note-preview \
  --tensor-parallel-size 4 \
  --pipeline-parallel-size 2 \
  --enable-prefix-caching \
  --max-model-len 524288 \
  --gpu-memory-utilization 0.94 \
  --kv-cache-dtype fp8 \
  --trust-remote-code \
  --port 8000

By keeping the immutable macro-step history cached in GPU VRAM, toggling into Critic mode requires materializing only the prompt delta ([CRITIC_EVAL_ENTER]), reducing TTFT from 4,200 ms down to 18 ms.

Section 8: Strategic Takeaways for Senior Systems Engineers

Scaffolding is a Band-Aid; Native RL is the Solution: External prompt-chaining loops (such as LangChain or custom while-loops) cannot cure the fundamental mathematical instability of an autoregressive policy drifting across 100 tool calls. Models must be post-trained to evaluate their own intermediate states.
The Macro-Step is the Right Abstraction: Trying to calculate reinforcement learning rewards at the individual token or single-tool-call level is mathematically doomed by variance. Grouping operations into verifiable macro-step contracts brings stability and convergence.
Sparse MoE + Test-Time Compute is the Frontier: The combination of lean active parameters (16B on a 280B substrate) and dynamic test-time reasoning tokens creates the optimal cost-intelligence frontier for autonomous software engineering.

The era of brittle, hallucination-prone AI agents is giving way to mathematically grounded, self-verifying systems. With dots3-note and TEMPO open-sourced under Apache 2.0, senior developers have the blueprint to build genuinely autonomous systems that scale without breaking. :::