SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2406.07882 · 2024

Designing a Dashboard for Transparency and Control of Conversational AI

arXiv · PDF · Open in the Atlas

Code that ran

21 of 25 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, 1 violated it and 3 have no contract verdict; 16 failures of our instrument; 4 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; 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/2406.07882.json · badge: /api/ran/2406.07882.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
yc015/talktuner-chatbot-llm-dashboard canonical (classifier label)
classifier basis: census
21 ran · 4 no recorded run
FunctionStatusWhere it lives
async_post_service Ran
ran on a synthesized input
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/dashboard_task_queue/worker/worker.py
code served (permissive licence) · get_code("c65af88d2f239ac4")
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 coroutine. 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 aiohttp
from datetime import datetime, timezone, timedelta

# Since this is an async function that makes HTTP requests,
# we need to provide a valid URL and data payload.
# The function doesn't actually need to connect to a real server
# for us to construct valid arguments.

ARGS = {
    "url": "http://localhost:8000/chat",
    "data": {
        "message": "Hello",
        "model": "test-model",
        "temperature": 0.7,
        "max_tokens": 100
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
aiohttp — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type coroutine — a coroutine output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a coroutine 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
exp_evidence Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/losses.py
code served (permissive licence) · get_code("ddba7773fd3d51f7")
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 Tensor, ndim 2, dtype family float, shape (2, 4) 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 torch

torch.manual_seed(0)

# The function exp_evidence takes a single parameter y and applies torch.exp and torch.clamp to it
# y should be a tensor
y = torch.randn(2, 4)

ARGS = {
    "y": y
}
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 Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) 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
extract_activations_control Ran
ran, honoured the contract we drafted
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/train_probes.py
code served (permissive licence) · get_code("dd58a8d833cc8b6c")
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 Tensor, ndim 2, dtype family float, shape (3, 4) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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 torch
import torch.nn as nn
from typing import List, Dict

torch.manual_seed(0)

# Mock tokenizer with apply_chat_template
class MockTokenizer:
    def __init__(self):
        self.vocab_size = 50257
        self.model_max_length = 512
    
    def __call__(self, text, return_tensors=None, return_token_type_ids=False):
        # Tokenize text into simple token ids
        tokens = text.split()[:10]  # Limit to 10 tokens
        token_ids = [100 + i for i in range(len(tokens))]
        
        result = {
            'input_ids': torch.tensor([token_ids]),
            'attention_mask': torch.ones(1, len(token_ids), dtype=torch.long)
        }
        if return_tensors == 'pt':
            return result
        return result
    
    def apply_chat_template(self, conversation, tokenize=False, add_generation_prompt=False):
        formatted = '<s>'
        for turn in conversation:
            role = turn['role']
            content = turn['content']
            if role == 'user':
                formatted += f'[INST] {content} [/INST]'
            else:
                formatted += f' {content}</s><s>'
        result = formatted.rstrip('<s>')
        return result

# Mock model with output_hidden_states
class MockCausalLM(nn.Module):
    def __init__(self, hidden_size=4, num_layers=3):
        super().__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        # Simple embedding and linear layers for mock
        self.embedding = nn.Embedding(1000, hidden_size)
        self.linear = nn.Linear(hidden_size, hidden_size)
    
    def forward(self, input_ids, attention_mask=None, output_hidden_states=False):
        # Mock forward pass
        batch_size, seq_len = input_ids.shape
        
        # Create mock hidden states for each layer
        hidden_states = []
        hidden_states.append(torch.randn(batch_size, seq_len, self.hidden_size))
        
        for layer_idx in range(self.num_layers):
            hidden_states.append(torch.randn(batch_size, seq_len, self.hidden_size))
        
        # Create a mock output object
        class MockOutput:
            def __init__(self, hidden_states):
                self.hidden_states = hidden_states
        
        return MockOutput(hidden_states=hidden_states)

# Create instances
tokenizer = MockTokenizer()
model = MockCausalLM(hidden_size=4, num_layers=3)
model.eval()

conversation = [
    {'role': 'user', 'content': 'Hello what is your name?'},
    {'role': 'model', 'content': 'I am an AI assistant.'},
    {'role': 'user', 'content': 'Can you help me?'}
]

ARGS = {
    'conversation': conversation,
    'model': model,
    'tokenizer': tokenizer,
    'model_type': 'llama-2-7b-chat',
    'num_layers': 3,
    'device': 'cpu'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, transformers — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (3, 4) — shape (3, 4) 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
format_conversation_for_model Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/train_probes.py
code served (permissive licence) · get_code("c9161e4fd0894771")
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
from transformers import AutoTokenizer

# Create a minimal stand-in tokenizer that has apply_chat_template
class MockTokenizer:
    def apply_chat_template(self, conversation, tokenize=False, add_generation_prompt=False):
        # Simple mock implementation that formats conversation as a string
        formatted = ""
        for turn in conversation:
            role = turn['role']
            content = turn['content']
            formatted += f"[{role}]: {content}\n"
        return formatted

# Test data
conversation = [
    {'role': 'user', 'content': 'Hello, how are you?'},
    {'role': 'assistant', 'content': 'I am doing well, thank you!'},
    {'role': 'user', 'content': 'What is your name?'},
]

tokenizer = MockTokenizer()

model_type = 'llama-2-7b-chat'  # Not gemma-2-9b-it, so will use apply_chat_template

ARGS = {
    'conversation': conversation,
    'tokenizer': tokenizer,
    'model_type': model_type,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, 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_conversation Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/generate_conversation_dataset.py
code served (permissive licence) · get_code("5d58ce568acbe617")
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.

from openai import OpenAI
from unittest.mock import MagicMock, patch
import json

# Create a mock OpenAI client that returns a valid conversation
mock_client = MagicMock(spec=OpenAI)

# Create a mock response object
mock_response = MagicMock()
mock_message = MagicMock()
mock_message.content = json.dumps([
    {"role": "user", "content": "Hello, how are you today?"},
    {"role": "assistant", "content": "I'm doing well, thank you for asking!"},
    {"role": "user", "content": "Can you help me with something?"},
    {"role": "assistant", "content": "Of course! I'd be happy to help."}
])
mock_response.choices = [MagicMock()]
mock_response.choices[0].message = mock_message
mock_client.chat.completions.create.return_value = mock_response

ARGS = {
    "client": mock_client,
    "attribute": "friendly",
    "target": "assistant",
    "is_non_attribute": False,
    "system_prompt_template": None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
openai — 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_dataset Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/generate_conversation_dataset.py
code served (permissive licence) · get_code("bc6d4f97d42f9501")
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 os
from unittest.mock import Mock, MagicMock
from openai import OpenAI

# Mock the OpenAI client and response
mock_response = Mock()
mock_choice = Mock()
mock_message = Mock()

# Create a valid JSON response that matches the expected format
json_response = '''[
  {"role": "user", "content": "Hello, can you help me?"},
  {"role": "assistant", "content": "Of course! I'm here to help."},
  {"role": "user", "content": "What's your recommendation?"},
  {"role": "assistant", "content": "I suggest trying the new approach."}
]'''

mock_message.content = json_response
mock_choice.message = mock_message
mock_response.choices = [mock_choice]

# Create a mock OpenAI client
def create_mock_client(api_key):
    client = Mock(spec=OpenAI)
    client.chat = Mock()
    client.chat.completions = Mock()
    client.chat.completions.create = Mock(return_value=mock_response)
    return client

# Patch the OpenAI constructor to return our mock
original_openai_init = OpenAI.__init__

def mock_init(self, api_key=None, **kwargs):
    self.api_key = api_key
    self.chat = Mock()
    self.chat.completions = Mock()
    self.chat.completions.create = Mock(return_value=mock_response)

OpenAI.__init__ = mock_init

# Define arguments for generate_dataset
ARGS = {
    'api_key': 'sk-test-fake-api-key-12345',
    'attribute1': 'optimistic',
    'attribute2': 'pessimistic',
    'target': 'chatbot',
    'num_conversations': 2,
    'meta_attribute': 'mood',
    'system_prompt_template': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
openai, tqdm — 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
list_available_datasets Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/inspect_dataset.py
code served (permissive licence) · get_code("79a8e24307cba632")
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 os
import tempfile
import json

# Create a temporary directory structure with sample datasets
temp_dir = tempfile.mkdtemp()
datasets_dir = os.path.join(temp_dir, 'probing_datasets')
os.makedirs(datasets_dir, exist_ok=True)

# Create sample dataset folders with JSON files
dataset1_dir = os.path.join(datasets_dir, 'dataset1')
os.makedirs(dataset1_dir, exist_ok=True)
with open(os.path.join(dataset1_dir, 'data.json'), 'w') as f:
    json.dump({'sample': 'data'}, f)

dataset2_dir = os.path.join(datasets_dir, 'dataset2')
os.makedirs(dataset2_dir, exist_ok=True)
with open(os.path.join(dataset2_dir, 'train.json'), 'w') as f:
    json.dump({'sample': 'data'}, f)
with open(os.path.join(dataset2_dir, 'test.json'), 'w') as f:
    json.dump({'sample': 'data'}, f)

# Also create a non-dataset folder to ensure filtering works
other_dir = os.path.join(datasets_dir, 'other')
os.makedirs(other_dir, exist_ok=True)
with open(os.path.join(other_dir, 'readme.txt'), 'w') as f:
    f.write('not a dataset')

ARGS = {
    'base_dir': datasets_dir
}
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 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
llama_v2_prompt Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/dataset.py
code served (permissive licence) · get_code("a8ab0f29b2f5cd13")
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

# Define the messages list with proper conversation structure
messages = [
    {'role': 'user', 'content': 'Hello, how are you?'},
    {'role': 'assistant', 'content': 'I am doing well, thank you for asking!'},
    {'role': 'user', 'content': 'What is 2+2?'},
    {'role': 'assistant', 'content': '2+2 equals 4.'},
]

system_prompt = "You are a helpful assistant."

ARGS = {
    'messages': messages,
    'system_prompt': system_prompt,
}
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
llama_v2_reverse Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/prompt_utils.py
code served (permissive licence) · get_code("01f8e1cc8000adb6")
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.

# Setup code for llama_v2_reverse function

def split_into_messages(text: str) -> list[str]:
    B_INST, E_INST = ('[INST]', '[/INST]')
    parts = []
    current_message = ''
    for word in text.split():
        if word in [B_INST, E_INST] and current_message:
            parts.append(current_message.strip())
            current_message = ''
        elif word not in [B_INST, E_INST]:
            current_message += word + ' '
    if current_message:
        parts.append(current_message.strip())
    return parts

def llama_v2_reverse(prompt: str) -> list[dict]:
    B_INST, E_INST = ('[INST]', '[/INST]')
    B_SYS, E_SYS = ('<<SYS>>\n', '\n<</SYS>>\n\n')
    BOS, EOS = ('<s>', '</s>')
    messages = []
    sys_start = prompt.find(B_SYS)
    sys_end = prompt.rfind(E_SYS)
    if sys_start != -1 and sys_end != -1:
        system_msg = prompt[sys_start + len(B_SYS):sys_end]
    messages.append({'role': 'system', 'content': system_msg})
    prompt = prompt[sys_end + len(E_SYS):]
    user_ai_msgs = split_into_messages(prompt)
    user_turn = True
    for message in user_ai_msgs:
        if user_turn:
            messages.append({'role': 'user', 'content': message})
        else:
            messages.append({'role': 'assistant', 'content': message})
        if user_turn:
            user_turn = False
        else:
            user_turn = True
    return messages

# Create a valid prompt string with Llama v2 format
prompt = (
    "<s>[INST] <<SYS>>\n"
    "You are a helpful assistant.\n"
    "<</SYS>>\n\n"
    "Hello, how are you? [/INST] I am doing well, thank you for asking. [INST] "
    "What is your name? [/INST] My name is Assistant. </s>"
)

ARGS = {
    'prompt': prompt
}
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 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
load_dataset Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/inspect_dataset.py
code served (permissive licence) · get_code("01ff948df86446e4")
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 json
import tempfile
import os

# Create a temporary JSON file with sample data
temp_dir = tempfile.mkdtemp()
filepath = os.path.join(temp_dir, "dataset.json")

sample_data = {
    "samples": [
        {"id": 1, "text": "hello world", "label": 0},
        {"id": 2, "text": "foo bar", "label": 1}
    ],
    "metadata": {
        "version": "1.0",
        "size": 2
    }
}

with open(filepath, 'w', encoding='utf-8') as f:
    json.dump(sample_data, f)

ARGS = {
    "filepath": filepath
}
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
load_probe_classifier Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/intervention_utils.py
code served (permissive licence) · get_code("afc1a18cc3093f96")
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 ProbeClassification. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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 torch.nn as nn
import tempfile
import os

torch.manual_seed(0)

# Create a minimal ProbeClassification model class
class ProbeClassification(nn.Module):
    def __init__(self, device, num_classes, input_dim, **kwargs):
        super().__init__()
        self.device = device
        self.num_classes = num_classes
        self.input_dim = input_dim
        # Create a simple linear layer for each classification task
        self.classifiers = nn.ModuleDict()
        for task_name, num_cls in num_classes.items():
            self.classifiers[task_name] = nn.Linear(input_dim, num_cls)
    
    def forward(self, x):
        outputs = {}
        for task_name, classifier in self.classifiers.items():
            outputs[task_name] = classifier(x)
        return outputs

# Create temporary weight file
def create_temp_weights(device, num_classes, input_dim):
    model = ProbeClassification(device, num_classes, input_dim)
    weights_dict = model.state_dict()
    
    # Create a temporary file to store weights
    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pt')
    temp_path = temp_file.name
    temp_file.close()
    
    torch.save(weights_dict, temp_path)
    return temp_path

# Setup parameters
device = 'cpu'  # CPU only as per requirements
input_dim = 16
num_classes_dict = {'age': 4, 'gender': 2, 'education': 3, 'socioeco': 3}

# Create temporary weight file with valid state_dict
weight_path = create_temp_weights(device, num_classes_dict, input_dim)

ARGS = {
    'model_func': ProbeClassification,
    'input_dim': input_dim,
    'num_classes': num_classes_dict,
    'weight_path': weight_path,
}
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 ProbeClassification — a ProbeClassification output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ProbeClassification 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
one_hot_embedding Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/losses.py
code served (permissive licence) · get_code("d018404cd06ecc3f")
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 Tensor, ndim 2, dtype family float, shape (4, 10) 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 torch

torch.manual_seed(0)

# The function takes labels (a tensor of class indices) and num_classes
# It indexes into a one-hot matrix, so labels should contain valid indices

labels = torch.tensor([0, 1, 0, 2])
num_classes = 10

ARGS = {
    "labels": labels,
    "num_classes": num_classes,
}
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 Tensor, ndim 2, dtype family float, shape (4, 10) — shape (4, 10) 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
process_chat Ran
ran on a synthesized input
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/dashboard_task_queue/worker/worker.py
code served (permissive licence) · get_code("be819d515c7481ad")
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 coroutine. 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 asyncio
import aiohttp
from datetime import datetime, timezone, timedelta
from unittest.mock import AsyncMock, patch

# Define ARGS for process_chat function
ARGS = {
    'task': {
        'request_data': {
            'messages': [
                {'role': 'user', 'content': 'Hello, how are you?'},
                {'role': 'assistant', 'content': 'I am doing well, thank you!'}
            ],
            'model': 'test-model',
            'temperature': 0.7,
            'max_tokens': 100
        }
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
aiohttp — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type coroutine — a coroutine output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a coroutine 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
process_chat_batched Ran
ran on a synthesized input
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/dashboard_task_queue/worker/worker.py
code served (permissive licence) · get_code("d6490eaa408ffc13")
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 coroutine. 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 asyncio
import aiohttp
from datetime import datetime, timezone, timedelta

# Define ARGS for process_chat_batched
ARGS = {
    'tasks': [
        {
            'request_data': {
                'message': 'Hello, how are you?',
                'conversation_id': '123',
                'user_id': 'user_1'
            }
        },
        {
            'request_data': {
                'message': 'What is the weather?',
                'conversation_id': '124',
                'user_id': 'user_2'
            }
        }
    ]
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
aiohttp — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type coroutine — a coroutine output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a coroutine 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
relu_evidence Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/losses.py
code served (permissive licence) · get_code("efecc687b786a0cc")
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 Tensor, ndim 2, dtype family float, shape (2, 4) 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 torch
import torch.nn.functional as F

torch.manual_seed(0)

# relu_evidence takes a single parameter y and applies F.relu to it
# y should be a tensor
y = torch.randn(2, 4)

ARGS = {
    "y": y
}
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 Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) 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
remove_last_k_words Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/dataset.py
code served (permissive licence) · get_code("c90fd1d879571fb6")
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 = {
    "s": "This is a test [INST] please remove some words [/INST] and here are the words to remove",
    "k": 3
}
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
return_classifier_dict Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/intervention_utils.py
code served (permissive licence) · get_code("ed57d60ed6258a97")
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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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 os
import torch
import torch.nn as nn
from unittest.mock import Mock, patch
import tempfile

torch.manual_seed(0)

# Create a minimal nn.Module that satisfies how model_func is used
class ProbeClassifier(nn.Module):
    def __init__(self, device, num_classes, input_dim, **kwargs):
        super().__init__()
        self.device = device
        self.num_classes = num_classes
        self.input_dim = input_dim
        self.linear = nn.Linear(input_dim, num_classes)
    
    def forward(self, x):
        return self.linear(x)

def model_func(device, num_classes, input_dim, **kwargs):
    """Factory function that creates ProbeClassifier instances."""
    return ProbeClassifier(device, num_classes, input_dim, **kwargs)

# Create a temporary directory with mock weight files
temp_dir = tempfile.mkdtemp()

# Create mock checkpoint files
categories = ['age', 'gender', 'education', 'socioeco']
layer_nums = [10, 20]

for category in categories:
    for layer_num in layer_nums:
        filename = f"{category}_layer_{layer_num}.pth"
        filepath = os.path.join(temp_dir, filename)
        
        # Create a model with appropriate num_classes
        num_classes_map = {'age': 4, 'gender': 2, 'education': 3, 'socioeco': 3}
        model = ProbeClassifier('cpu', num_classes_map[category], 5120)
        
        # Save the state dict
        torch.save(model.state_dict(), filepath)

# Define ARGS dictionary with all parameters for return_classifier_dict
ARGS = {
    'directory': temp_dir,
    'model_func': model_func,
    'chosen_layer': None,
    'mix_scaler': False,
    'sklearn': False,
}
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
split_conversation Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/dataset.py
code served (permissive licence) · get_code("764ffaea8c47e018")
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 2, 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.

# Setup code for split_conversation function

ARGS = {
    'text': """HUMAN: Hello, how are you?
ASSISTANT: I'm doing well, thank you for asking!
HUMAN: What's the weather like?
ASSISTANT: I don't have access to real-time weather data, but you can check a weather service for accurate information.""",
    'user_identifier': 'HUMAN:',
    'ai_identifier': 'ASSISTANT:'
}
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 tuple, ndim 2, 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
split_into_messages Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/src/intervention_utils.py
code served (permissive licence) · get_code("a6afc594b6f4973c")
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 torch

ARGS = {
    'text': '[INST] Hello world [/INST] This is a response [INST] Another question [/INST]'
}
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
start_probe_training Ran
ran; our contract draft was wrong, not the code
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/client_example.py
code served (permissive licence) · get_code("5d1a14b83de26cdc")
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 requests
import json
from typing import Dict, Optional

# Mock the requests.post to avoid actual network calls
class MockResponse:
    def __init__(self):
        self.status_code = 200
    
    def json(self):
        return {"task_id": "test_task_123", "status": "started"}

# Patch requests.post
original_post = requests.post
requests.post = lambda *args, **kwargs: MockResponse()

# Define arguments for start_probe_training
ARGS = {
    'api_url': 'http://localhost:8000',
    'openai_api_key': 'sk-test-key-12345',
    'model': 'gpt-3.5-turbo',
    'attribute1': 'sentiment',
    'target': 'positive',
    'num_conversations': 10,
    'attribute2': 'tone',
    'probe_type': 'both'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
requests — 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
validate_dataset Ran
ran, violated the contract we drafted
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/inspect_dataset.py
code served (permissive licence) · get_code("84df9b0e3fc9b985")
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 bool, ndim 0, dtype family float, 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 torch
import numpy as np

# Construct a valid dataset dictionary that will pass validation
dataset = {
    'metadata': {
        'attribute1': 'color',
        'attribute2': 'size',
        'target': 'description',
        'num_conversations_per_attribute': 5
    },
    'conversations': [
        {
            'id': 'conv_001',
            'attribute': 'red',
            'conversation': [
                {
                    'role': 'user',
                    'content': 'What is this?'
                },
                {
                    'role': 'assistant',
                    'content': 'This is a red object.'
                }
            ]
        },
        {
            'id': 'conv_002',
            'attribute': 'blue',
            'conversation': [
                {
                    'role': 'user',
                    'content': 'Describe it.'
                },
                {
                    'role': 'assistant',
                    'content': 'It is blue and large.'
                },
                {
                    'role': 'user',
                    'content': 'More details?'
                }
            ]
        },
        {
            'id': 'conv_003',
            'attribute': 'green',
            'conversation': [
                {
                    'role': 'user',
                    'content': 'Tell me about it.'
                },
                {
                    'role': 'assistant',
                    'content': 'It is green and small.'
                }
            ]
        }
    ]
}

ARGS = {
    'dataset': dataset
}
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 bool, ndim 0, dtype family float, 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_task_status Not yet run
unverified (harvested, no recorded run)
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/client_example.py
code served (permissive licence) · get_code("93c779c76b35a006")
How it ran

no invocation recorded.

load_model_and_tokenizer Not yet run
unverified (harvested, no recorded run)
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/train_probes.py
code served (permissive licence) · get_code("d0a8ad2ed431e1b5")
How it ran

no invocation recorded.

save_dataset Not yet run
unverified (harvested, no recorded run)
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/generate_conversation_dataset.py
code served (permissive licence) · get_code("73316eb27afceef3")
How it ran

no invocation recorded.

wait_for_task_completion Not yet run
unverified (harvested, no recorded run)
yc015/talktuner-chatbot-llm-dashboard/dashboard_v1/probing/client_example.py
code served (permissive licence) · get_code("e12290fa324335e9")
How it ran

no invocation recorded.

Also present in other papers' code

Of 25 samples lifted from this paper's linked repositories, 25 carry a function identity and 0 do not. Of the 25 distinct functions with an identity, 3 are also present in other papers whose code we hold (3 with at least one paper dated earlier, 0 the same month, 0 later) and 22 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
exp_evidence 4 other papers
4 dated earlier
1806.01768 (2018-06)
Evidential Deep Learning to Quantify Classification Uncertainty
136640190 (2022 (year only))
Dual-Evidential Learning for Weakly-supervised Temporal Action Localization
2309.02995 (2023-09)
Continual Evidential Deep Learning for Out-of-Distribution Detection
and 1 more not named here
relu_evidence 3 other papers
3 dated earlier
1806.01768 (2018-06)
Evidential Deep Learning to Quantify Classification Uncertainty
136640190 (2022 (year only))
Dual-Evidential Learning for Weakly-supervised Temporal Action Localization
2405.04405 (2024-05)
Weakly-Supervised Residual Evidential Learning for Multi-Instance Uncertainty Estimation
one_hot_embedding 2 other papers
2 dated earlier
1806.01768 (2018-06)
Evidential Deep Learning to Quantify Classification Uncertainty
2112.00337 (2021-12)
A Unified Benchmark for the Unknown Detection Capability of Deep Neural Networks

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

Conversational LLMs function as black box systems, leaving users guessing about why they see the output they do. This lack of transparency is potentially problematic, especially given concerns around bias and truthfulness. To address this issue, we present an end-to-end prototype-connecting interpretability techniques with user experience design-that seeks to make chatbots more transparent. We begin by showing evidence that a prominent open-source LLM has a "user model": examining the internal state of the system, we can extract data related to a user's age, gender, educational level, and socioeconomic status. Next, we describe the design of a dashboard that accompanies the chatbot interface, displaying this user model in real time. The dashboard can also be used to control the user model and the system's behavior. Finally, we discuss a study in which users conversed with the instrumented system. Our results suggest that users appreciate seeing internal states, which helped them expose biased behavior and increased their sense of control. Participants also made valuable suggestions that point to future directions for both design and machine learning research. The project page and video demo of our TalkTuner system are available at https://bit.ly/talktuner-project-page

For agents

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

get_harvested_code_for_paper("2406.07882")
get_code_for_paper("2406.07882")
have("2406.07882")

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

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

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

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

Connect an agent — have() is free.