SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2602.11683 · 2026

THINKROUTER: Efficient Reasoning via Routing Thinking between Latent and Discrete Spaces

Julian Mcauley, Xiang Chen, Tong Yu, Xin Xu, Saayan Mitra, Haoliang Wang

arXiv · PDF · Open in the Atlas

Code that ran

13 of 16 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 12 failures of our instrument; 3 no recorded run), measured 2026-11-22; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2602.11683.json · badge: /api/ran/2602.11683.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
eric-ai-lab/Soft-Thinking canonical (classifier label)
classifier basis: census
13 ran · 3 no recorded run
FunctionStatusWhere it lives
benchmark_sequential_vs_batch Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/benchmark_batch/benchmark_tokenizer.py
code served (permissive licence) · get_code("64f004b9216b7322")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import time
from statistics import mean

class MockTokenizer:
    """Mock tokenizer that supports both sequential and batch encoding."""
    
    def encode(self, prompt):
        """Encode a single prompt into tokens."""
        # Return a list of token ids
        return [1, 2, 3] * len(prompt.split())
    
    def __call__(self, prompts):
        """Batch encode multiple prompts."""
        # Handle both single string and list of strings
        if isinstance(prompts, str):
            prompts = [prompts]
        return [[1, 2, 3] * len(p.split()) for p in prompts]


# Create setup arguments
prompts = [
    "Hello world this is a test prompt",
    "Another sample prompt for benchmarking",
    "Third prompt with some content here",
    "Fourth test prompt string example",
    "Fifth and final prompt for testing",
]

batch_size = 3

tokenizer = MockTokenizer()

ARGS = {
    "prompts": prompts,
    "batch_size": batch_size,
    "tokenizer": tokenizer,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_event_triple_prompt Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/generative_agents/agent_functions.py
code served (permissive licence) · get_code("83900d0c3ab83065")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

ARGS = {
    'persona_name': 'Alice Smith',
    'action': 'is reading a book'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_pronunciatio_prompt Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/generative_agents/agent_functions.py
code served (permissive licence) · get_code("577ff88cf5082d20")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

# The function takes a single parameter: action (a string)
# It constructs a prompt string using the action and returns a dict
# No complex objects needed - just a simple string input

ARGS = {
    'action': 'jumping over a fence'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_random_prompt Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/benchmark_batch/benchmark_batch.py
code served (permissive licence) · get_code("9afb749e3f5b90cf")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import random
from unittest.mock import MagicMock
from transformers import AutoTokenizer

# Create a mock tokenizer that doesn't require downloading
mock_tokenizer = MagicMock()
mock_tokenizer.vocab_size = 1000
mock_tokenizer.decode = lambda token_ids, clean_up_tokenization_spaces=True: " ".join([f"token_{i}" for i in token_ids])

# Mock the AutoTokenizer.from_pretrained to return our mock tokenizer
original_from_pretrained = AutoTokenizer.from_pretrained
def mock_from_pretrained(tokenizer_dir):
    return mock_tokenizer

AutoTokenizer.from_pretrained = mock_from_pretrained

ARGS = {
    "index": 0,
    "tokenizer_dir": "mock_tokenizer_path",
    "num_tokens": 5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
transformers — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_random_prompts Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/benchmark_batch/benchmark_tokenizer.py
code served (permissive licence) · get_code("5139455c0f07d032")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import random
import torch

class MockTokenizer:
    """Mock tokenizer that simulates the required interface."""
    def __init__(self, vocab_size=1000):
        self.vocab_size = vocab_size
    
    def decode(self, token_ids, clean_up_tokenization_spaces=True):
        """Decode token ids to text."""
        return ' '.join([f'token_{tid}' for tid in token_ids])
    
    def encode(self, text):
        """Encode text to token ids."""
        # Return a list of token ids based on text length
        return list(range(len(text.split())))

torch.manual_seed(0)
random.seed(0)

ARGS = {
    'num_prompts': 3,
    'num_tokens': 5,
    'tokenizer': MockTokenizer(vocab_size=500)
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_unique_prefix Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/bench_in_batch_prefix/bench_in_batch_prefix.py
code served (permissive licence) · get_code("19faa93c902e1c91")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

ARGS = {
    "base_text": "hello world example",
    "index": 5
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_answer_value Ran
ran, honoured the contract we drafted
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/gsm8k/bench_other.py
code served (permissive licence) · get_code("4c13c3bdb761b46c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import ast
import re

INVALID = -9999999

def get_answer_value(answer_str):
    answer_str = answer_str.replace(',', '')
    numbers = re.findall('\\d+', answer_str)
    if len(numbers) < 1:
        return INVALID
    try:
        return ast.literal_eval(numbers[-1])
    except SyntaxError:
        return INVALID


ARGS = {
    'answer_str': "The answer is 42"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_few_shot_examples Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/gsm8k/bench_other.py
code served (permissive licence) · get_code("9e0d3df1a2d9a123")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

# Create sample lines data structure
lines = [
    {
        'question': 'What is the capital of France?',
        'answer': 'Paris'
    },
    {
        'question': 'What is 2 + 2?',
        'answer': '4'
    },
    {
        'question': 'What is the largest planet?',
        'answer': 'Jupiter'
    }
]

# Define ARGS for get_few_shot_examples function
ARGS = {
    'lines': lines,
    'k': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_few_shot_examples Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/hellaswag/bench_other.py
code served (permissive licence) · get_code("06681001174b0ca9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

# Construct the lines argument - a list of dicts with the required structure
lines = [
    {
        'activity_label': 'cooking',
        'ctx': 'The chef prepared the ingredients on the counter.',
        'endings': ['with a knife', 'with a fork', 'with a spoon', 'with chopsticks'],
        'label': 1
    },
    {
        'activity_label': 'eating',
        'ctx': 'The person sat down at the table.',
        'endings': ['and slept', 'and ate', 'and ran', 'and jumped'],
        'label': 1
    },
    {
        'activity_label': 'playing',
        'ctx': 'The child went to the park.',
        'endings': ['to study', 'to play games', 'to sleep', 'to work'],
        'label': 1
    }
]

ARGS = {
    'lines': lines,
    'k': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_one_example Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/gsm8k/bench_other.py
code served (permissive licence) · get_code("2e994f473fac61f9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Construct valid arguments for get_one_example
lines = [
    {
        'question': 'What is 2+2?',
        'answer': '4'
    },
    {
        'question': 'What is the capital of France?',
        'answer': 'Paris'
    }
]

ARGS = {
    'lines': lines,
    'i': 0,
    'include_answer': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_one_example Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/hellaswag/bench_other.py
code served (permissive licence) · get_code("5b4a33e73835b337")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

# Construct a valid lines argument
# The function expects lines[i] to have keys: 'activity_label', 'ctx', 'endings', 'label'
lines = [
    {
        'activity_label': 'cooking',
        'ctx': 'A person is in the kitchen preparing ingredients.',
        'endings': ['boiling water', 'frying an egg', 'baking a cake'],
        'label': 1
    },
    {
        'activity_label': 'sports',
        'ctx': 'Two athletes are competing on the field.',
        'endings': ['running a race', 'playing soccer', 'throwing a ball'],
        'label': 0
    }
]

ARGS = {
    'lines': lines,
    'i': 0,
    'include_answer': True
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
poignancy_event_prompt Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/generative_agents/agent_functions.py
code served (permissive licence) · get_code("e4b32a865322152c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

ARGS = {
    'persona_name': 'Alice',
    'persona_iss': 'Alice is a 28-year-old software engineer who values career growth and maintains close relationships with her family. She is ambitious but also struggles with work-life balance.',
    'event': 'Alice receives a job offer from her dream company with a 40% salary increase, but it requires relocating to another country away from her family.'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
send_batch_request Ran
ran; our contract draft was wrong, not the code
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/benchmark_batch/benchmark_batch.py
code served (permissive licence) · get_code("5bc9a6f07218ab7b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import time
import requests
from unittest.mock import Mock, patch
import torch

# Create a mock endpoint object with base_url attribute
endpoint = Mock()
endpoint.base_url = "http://localhost:8000"

# Create a list of prompts
prompts = [
    "What is machine learning?",
    "Explain neural networks."
]

# Number of tokens to generate
gen_tokens = 100

# Request identifier
request_id = "req_001"

# Mock the requests.post to avoid actual network calls
def mock_post(url, json=None, timeout=None):
    """Mock response for requests.post"""
    mock_response = Mock()
    mock_response.status_code = 200
    mock_response.json = Mock(return_value={
        "generated_text": ["Response 1", "Response 2"]
    })
    return mock_response

# Patch requests.post before defining ARGS
with patch('requests.post', side_effect=mock_post):
    ARGS = {
        'endpoint': endpoint,
        'prompts': prompts,
        'gen_tokens': gen_tokens,
        'request_id': request_id
    }
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
requests, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_random_string Not yet run
unverified (harvested, no recorded run)
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/bench_in_batch_prefix/bench_in_batch_prefix.py
code served (permissive licence) · get_code("70f1d10961d52f6d")
How it ran

no invocation recorded.

prepare_all_prompts Not yet run
unverified (harvested, no recorded run)
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/benchmark_batch/benchmark_batch.py
code served (permissive licence) · get_code("60d747ff8e6ab539")
How it ran

no invocation recorded.

prepare_prompts Not yet run
unverified (harvested, no recorded run)
eric-ai-lab/Soft-Thinking/sglang_soft_thinking_pkg/benchmark/bench_in_batch_prefix/bench_in_batch_prefix.py
code served (permissive licence) · get_code("e5914c7114b177c6")
How it ran

no invocation recorded.

Also present in other papers' code

Of 16 samples lifted from this paper's linked repositories, 16 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 15 are also present in other papers whose code we hold (15 with at least one paper dated earlier, 1 the same month, 11 later) and 0 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
get_answer_value 3 other papers
2 dated earlier, 1 the same month
2312.07104 (2023-12)
SGLang: Efficient Execution of Structured Language Model Programs
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2602.10718 (2026-02)
SnapMLA: Efficient Long-Context MLA Decoding via Hardware-Aware FP8 Quantized Pipelining
get_one_example 3 other papers
3 dated earlier
2312.07104 (2023-12)
SGLang: Efficient Execution of Structured Language Model Programs
2406.18665 (2024-06)
RouteLLM: Learning to Route LLMs with Preference Data
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
benchmark_sequential_vs_batch 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
generate_event_triple_prompt 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
generate_pronunciatio_prompt 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
generate_random_prompt 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
generate_random_prompts 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
generate_random_string 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
generate_unique_prefix 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
get_few_shot_examples 2 other papers
2 dated earlier
2312.07104 (2023-12)
SGLang: Efficient Execution of Structured Language Model Programs
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
poignancy_event_prompt 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
prepare_all_prompts 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
prepare_prompts 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
send_batch_request 2 other papers
1 dated earlier, 1 later
2601.18999 (2026-01)
Randomization Boosts KV Caching, Learning Balances Query Load: A Joint Perspective
2604.27998 (2026-04)
Latent-GRPO: Group Relative Policy Optimization for Latent Reasoning
get_one_example 1 other paper
1 dated earlier
2312.07104 (2023-12)
SGLang: Efficient Execution of Structured Language Model Programs

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Recent work explores latent reasoning to improve reasoning efficiency by replacing explicit reasoning trajectories with continuous representations in a latent space, yet its effectiveness varies across settings. Analysis of model confidence dynamics under latent reasoning reveals that thinking trajectories ending in incorrect answers contain fewer low-confidence steps than those ending in correct answers. Meanwhile, we suggest that soft embeddings aggregated by multiple low-confidence thinking alternatives may introduce and propagate noise, leading to high confidence in unreliable reasoning trajectories. Motivated by these observations, THINKROUTER, an inference-time confidence-aware routing mechanism is proposed to avoid high confidence and noise for efficient reasoning. THINKROUTER routes thinking to the discrete token space when model confidence is low, and to the latent space otherwise. Extensive experiments on STEM reasoning and coding benchmarks across diverse large reasoning models demonstrate that THINKROUTER outperforms explicit CoT, random routing, and latent reasoning baselines in terms of accuracy, achieving an average improvement of 19.70 points in Pass@1, while reducing generation length by up to 15.55%. Further comprehensive analysis reveals that THINKROUTER can calibrate errors arising from explicit CoT and latent reasoning, and accelerates end-of-thinking token generation by globally lowering model confidence.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2602.11683")
get_code_for_paper("2602.11683")
have("2602.11683")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2602.11683.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2602.11683.svg)](https://syntology.ai/paper/2602.11683)

Connect an agent — have() is free.