Uncategorized

Prime Intellect launched verifiers 0.2.0. It previews a rewritten core, shipped under the new verifiers.v1 namespace. Modern evaluations now run coding agents with tools, compaction, and subagents. Accordingly, v1 rebuilds environments to run these agentic workloads at scale. What is verifiers v1? First, consider what verifiers is: Prime Intellect’s environment stack for agentic reinforcement learning and evaluations. Previously, an environment bundled its data, agent logic, and infrastructure together. In contrast, v1 breaks that bundle into three composable pieces. A taskset defines the work: the data, tools, and scoring. A harness solves the task and produces a rollout. That harness can be a ReAct loop, a CLI agent, or your own. The rollout then runs inside a runtime, either local or in a sandbox. Because the pieces decouple, any taskset runs under any compatible harness. How the Architecture Works? With those pieces defined, the next question is how they communicate. The central piece is the verifiers-managed interception server. It sits between the agent’s runtime and the inference server. Specifically, it proxies requests to, and responses from, inference. Meanwhile, it records the trace, sets sampling parameters, and can rewrite tool responses. That rewriting helps mitigate reward hacks during training. For scale, each server multiplexes a constant number of rollouts, defaulting to 32. A pool then scales elastically with observed concurrency. The server also owns a client that relays those requests. During evaluation, an EvalClient acts as a blind HTTP proxy. During training, a TrainClient wraps renderers for faithful token-in RL training. Because harnesses speak different dialects, verifiers supports three as of now. These are OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages. A dialect adapter normalizes each wire format into canonical vf.types. Consequently, your scoring logic stays independent of the agent tested. Run rollout</button> <button id=”vf-reset” class=”vf-ghost”>Reset</button> <span class=”vf-lab”>Harness dialect:</span> <select id=”vf-dialect”> <option value=”Chat”>OpenAI Chat Completions</option> <option value=”Resp”>OpenAI Responses</option> <option value=”Msg”>Anthropic Messages</option> </select> </div> <div class=”vf-stage”> <div class=”vf-row” style=”margin-bottom:14px”> <div class=”vf-node vf-taskset” id=”n-taskset”> <div class=”vf-nt”>Taskset</div> <div class=”vf-nd”>what · data · tools · scoring</div> </div> </div> <div class=”vf-runtime-wrap”> <span class=”vf-runtime-tag”>RUNTIME · where (subprocess · Docker · sandbox)</span> <div class=”vf-row” id=”vf-flow”> <div class=”vf-node vf-harness” id=”n-harness”> <div class=”vf-nt”>Harness</div> <div class=”vf-nd”>how · Codex · Terminus 2 · ReAct</div> </div> <div class=”vf-arrow”>→</div> <div class=”vf-node vf-intercept” id=”n-intercept”> <div class=”vf-nt”>Interception Server</div> <div class=”vf-nd”>proxy · records trace</div> </div> <div class=”vf-arrow”>→</div> <div class=”vf-node vf-infer” id=”n-infer”> <div class=”vf-nt”>Inference Server</div> <div class=”vf-nd”>vLLM · model</div> </div> <div class=”vf-packet” id=”vf-packet”>req</div> </div> </div> <div class=”vf-status” id=”vf-status”>Press “Run rollout” to send a request through the interception server.</div> </div> <div class=”vf-grid”> <div class=”vf-panel”> <h3>Trace · message graph (v1)</h3> <div class=”vf-hint”>Each message is a unique node. Size grows linearly in turns.</div> <div class=”vf-graph” id=”vf-graph”> <div class=”vf-empty”>No messages recorded yet.</div> </div> </div> <div class=”vf-panel”> <h3>Trace size: v0 vs v1</h3> <div class=”vf-hint”>Drag to change turns. v0 repeats prompt-completion pairs; v1 stores unique nodes.</div> <div class=”vf-chart”> <svg viewBox=”0 0 260 150″ id=”vf-svg”> <line x1=”30″ y1=”130″ x2=”255″ y2=”130″ stroke=”#dfe6ef” stroke-width=”1.5″/> <line x1=”30″ y1=”10″ x2=”30″ y2=”130″ stroke=”#dfe6ef” stroke-width=”1.5″/> <path id=”vf-v0″ fill=”none” stroke=”#d1477a” stroke-width=”2.5″/> <path id=”vf-v1″ fill=”none” stroke=”#0b8f8f” stroke-width=”2.5″/> <text x=”140″ y=”147″ font-size=”9″ fill=”#94a3b8″ text-anchor=”middle”>turns →</text> </svg> </div> <div class=”vf-legend”> <span><i style=”background:#d1477a”></i> v0 · quadratic</span> <span><i style=”background:#0b8f8f”></i> v1 · linear</span> </div> <div class=”vf-slider-row”> <span>Turns</span> <input type=”range” id=”vf-turns” min=”4″ max=”60″ value=”24″> <span id=”vf-turns-val” style=”width:26px;text-align:right”>24</span> </div> </div> </div> <div class=”vf-foot”> Illustrative demo of the verifiers v1 architecture · Built by <b>Marktechpost</b> </div> </div> <script> (function(){ var root=document.getElementById(“vfv1-demo”); var packet=document.getElementById(“vf-packet”); var status=document.getElementById(“vf-status”); var graph=document.getElementById(“vf-graph”); var runBtn=document.getElementById(“vf-run”); var resetBtn=document.getElementById(“vf-reset”); var dialectSel=document.getElementById(“vf-dialect”); var nHarness=document.getElementById(“n-harness”); var nIntercept=document.getElementById(“n-intercept”); var nInfer=document.getElementById(“n-infer”); var flow=document.getElementById(“vf-flow”); var turn=0, running=false; var msgs=[]; // recorded nodes var dialectLabel={Chat:”Chat”,Resp:”Resp”,Msg:”Msg”}; function pos(el){ // center x relative to flow var f=flow.getBoundingClientRect(); var r=el.getBoundingClientRect(); return (r.left – f.left) + r.width/2 – 32; } function clearActive(){ [nHarness,nIntercept,nInfer].forEach(function(n){n.classList.remove(“vf-active”);}); } function movePacket(fromEl,toEl,ms,label,isResp){ return new Promise(function(res){ packet.textContent=label; packet.classList.toggle(“vf-resp”,!!isResp); packet.style.transition=”none”; packet.style.left=pos(fromEl)+”px”; packet.style.opacity=”1″; void packet.offsetWidth; packet.style.transition=”left “+ms+”ms cubic-bezier(.45,.05,.35,1)”; packet.style.left=pos(toEl)+”px”; setTimeout(res,ms); }); } function addNode(role,label,color){ if(msgs.length===0){ graph.innerHTML=””; } var d=document.createElement(“div”); d.className=”vf-msg”; d.innerHTML='<span class=”vf-dot” style=”background:’+color+’”></span><code>’+label+'</code><span class=”vf-role”>’+role+'</span>’; graph.appendChild(d); graph.scrollTop=graph.scrollHeight; msgs.push(label); } function sleep(ms){return new Promise(function(r){setTimeout(r,ms);});} async function runTurn(){ if(running) return; running=true; runBtn.disabled=true; turn++; var dl=dialectLabel[dialectSel.value]; // seed system + user on first turn if(turn===1){ addNode(“system”,”S1″,”#6366f1″); await sleep(160); addNode(“user”,”U1″,”#6366f1″); } clearActive(); nHarness.classList.add(“vf-active”); status.textContent=”Harness builds a “+dl+” request…”; await sleep(350); // harness -> interception nIntercept.classList.add(“vf-active”); status.textContent=”Interception server proxies the request → inference.”; await movePacket(nHarness,nInfer,850,dl+” req”); clearActive(); nInfer.classList.add(“vf-active”); status.textContent=”Inference server generates the reply (vLLM).”; await sleep(350); // inference -> interception (records) -> harness nIntercept.classList.add(“vf-active”); status.textContent=”Interception server records the trace, relays the response.”; await movePacket(nInfer,nHarness,850,”resp”,true); packet.style.opacity=”0″; clearActive(); // record assistant node (+ occasional tool) addNode(“assistant”,”A”+turn,”#0b8f8f”); await sleep(150); if(turn%2===0){ addNode(“tool”,”T”+turn,”#e0a800″); } status.textContent=”Turn “+turn+” recorded as a unique node in the message graph.”; running=false; runBtn.disabled=false; } function reset(){ turn=0; msgs=[]; running=false; runBtn.disabled=false; clearActive(); packet.style.opacity=”0″; graph.innerHTML='<div class=”vf-empty”>No messages recorded yet.</div>’; status.textContent=”Press “Run rollout” to send a request through the interception server.”; } runBtn.addEventListener(“click”,runTurn); resetBtn.addEventListener(“click”,reset); // —- v0 vs v1 growth chart —- var v0=document.getElementById(“vf-v0”); var v1=document.getElementById(“vf-v1”); var turnsR=document.getElementById(“vf-turns”); var turnsV=document.getElementById(“vf-turns-val”); function drawChart(N){ var x0=30,x1=255,y0=130,y1=12,W=x1-x0,H=y0-y1; var maxV0=N*N; // quadratic reference function ptV0(i){var x=x0+(i/N)*W;var y=y0-((i*i)/maxV0)*H;return x+”,”+y;} function ptV1(i){var x=x0+(i/N)*W;var y=y0-((i/N)*H);return x+”,”+y;} // linear var p0=”M”,p1=”M”; for(var i=0;i<=N;i++){ p0+=(i?” L”:””)+ptV0(i); p1+=(i?” L”:””)+ptV1(i); } v0.setAttribute(“d”,p0); v1.setAttribute(“d”,p1); } turnsR.addEventListener(“input”,function(){ turnsV.textContent=turnsR.value; drawChart(+turnsR.value); }); drawChart(+turnsR.value); // —- auto-resize for WordPress iframe embedding —- function sendHeight(){ var h=document.getElementById(“vfv1-demo”).offsetHeight+40; if(window.parent){ window.parent.postMessage({vfv1Height:h},”*”); } } window.addEventListener(“load”,sendHeight); window.addEventListener(“resize”,sendHeight); new MutationObserver(sendHeight).observe(document.getElementById(“vf-graph”),{childList:true}); setInterval(sendHeight,1200); })(); </script> </body> </html> “> v0 vs v1: A Quick Comparison These changes separate v1 from v0. Aspect verifiers v0 verifiers v1 Environment model Data, logic, and infra bundled together Split into taskset, harness, runtime Trace growth Quadratic in turns (repeated pairs) Linear in turns (unique nodes) Non-linear rollouts Assumed linear Native compaction and subagents via branches Runtime handling Builder manages lifecycle Framework-managed run / read / write Harness coupling Tightly coupled to the environment Any compatible harness (Codex, Terminus 2) Training data Recomputed for prime-rl Consumed directly from the trace Use Cases with Examples With the architecture clear, consider how teams use it. For example, you can run Nemotron 3 Ultra on Terminal-Bench 2 under Codex. Similarly, teams can reuse Harbor datasets without rewriting reward logic. Prime Intellect ported Terminal Bench 2 into v1 with only a small class. In its internal testing, verifiers matched Harbor’s performance

Agentic LLMs often fail the same way, again and again. A Stanford research team traced this to missing, reusable capabilities. Their system, TRACE, diagnoses those gaps and trains for them directly. TRACE stands for Turning Recurrent Agent failures into Capability-targeted training Environments. It was released open-source under an MIT license. What problem does TRACE solve? To understand the design, first consider why agents fail. They lack specific skills that tasks demand, like retrieving the right record or verifying a precondition. Two mainstream fixes spend compute poorly. Direct RL or SFT gives sparse rewards that never say which skill was missing. Broad synthetic data is untargeted, so budget flows to skills the model already has. However, TRACE observes that failures are not random. A small set of deficits accounts for most failed trajectories. Therefore, each recurring deficit can become its own dense, verifiable training signal. How does TRACE work? Given that findings, TRACE runs an automated four-step pipeline. Each step is driven by an LLM agent following a markdown prompt. Step 1: Contrastive capability analysis The base agent generates rollouts in the target environment. An analysis agent splits them into successful and failed sets. It then labels every trajectory-capability pair as NA, PRESENT, or LACKING. A capability is retained only when it is contrastive and high-coverage. Specifically, its contrastive gap must clear δ = 0.20 and coverage must clear ρ = 0.10. Consequently, the pipeline keeps skills whose absence concentrates in failures. Step 2: Targeted environment synthesis Next, a generation agent builds one synthetic environment per retained capability. Each environment isolates a single capability while preserving the target’s tool schemas and format. Task instances are procedurally generated from random seeds. Because generation and verification are algorithmic, rewards need no human labels or LLM judge. Step 3: Capability adapter training Then each capability gets one LoRA (Low-Rank Adaptation) adapter, trained on its synthetic environment. The training algorithm is GRPO (Group Relative Policy Optimization). The base model stays frozen throughout. GRPO groups rollouts by shared seed, so scenarios are identical within a group. Rewards are then normalized within each group to isolate the policy’s contribution. Step 4: MoE composition with token-level routing Finally, TRACE composes the adapters into a Mixture-of-Experts (MoE) model. The backbone and adapters stay frozen, and only lightweight token-level gates are trained. At inference, each token is routed top-1 to a single capability adapter. This lets the model switch experts mid-trajectory. How TRACE Works — Interactive Explainer Interactive Explainer How TRACE Turns Agent Failures Into Targeted Training TRACE diagnoses the capabilities an agent lacks, builds one verifiable environment per gap, trains a LoRA expert for each, then routes tokens across experts. Step through the pipeline below. 1 · Contrastive Capability Analysis Split rollouts into pass / fail, then keep gaps that separate them. Passed  (D⁺) Failed  (D⁻) Retained if Δ ≥ 0.20 and Cov ≥ 0.10 2 · Targeted Environment Synthesis One seeded, auto-verifiable environment is generated per capability. 3 · Capability Adapter Training (GRPO) Rollouts share a seed; rewards are normalized within the group. 0%LoRA Δc  (~5.3%) Base model frozen · only Δc updates 4 · MoE Composition · Token-Level Routing A learned gate routes each token top-1 to a single capability expert. Pick a task above to route its tokens. Play step Next step → Result · τ²-Bench overall pass rate (Qwen3-30B-A3B) Targeted training and MoE composition beat prompt optimization and single-adapter baselines. Built from arXiv:2604.05336 · code. Numbers are from the paper.  •  Marktechpost

This story originally appeared in The Algorithm, our weekly newsletter on AI. To get stories like this in your inbox first, sign up here. Anthropic—currently the world’s most valuable AI company, with a nearly $1 trillion valuation—has a reputation for publishing strange and heady research. It’s looking into whether AI models can feel pain, for example, and will sometimes cut off chatbot conversations if it suspects users are “abusing” the model.  One niche that Anthropic spends more time and money on than other AI companies is called mechanistic interpretability, which means looking inside the complex math of an AI model to learn why it comes up with one particular output and not another. It’s complicated stuff; there are millions of data points that might contribute to any result, and wading through them can look more like word salad than anything useful. It’s also controversial. Describing AI models with terms borrowed from psychology and neuroscience can make their behavior seem more sophisticated than we might otherwise judge it to be. That’s why, when Anthropic announced last week that it had found a new window into its models’ “internal thoughts” as they reason through answers, there was one colleague I had to talk to. Senior editor Will Douglas Heaven, aside from having a PhD in computer science, has spent a lot of time digging into what we can say about how AI models work. I spoke with him about what we should take from Anthropic’s new (and predictably quirky) research. What did Anthropic learn here, exactly? Anthropic has been trying to understand how large language models (LLMs) work for a few years now. Anthropic isn’t the only one looking at this, but I think the company has made it part of its core mission more than most. Anthropic’s CEO, Dario Amodei, has said we won’t be able to control LLMs fully unless we learn more about how they work.  So this new research is very much in that context. It goes deeper into the weird mechanisms inside LLMs than ever before. What Anthropic learned was that LLMs have a space inside them—which Anthropic calls the J-space—filled with words that don’t appear in their output but that seem to influence the way they puzzle through problems. All this was hidden until Anthropic developed a new technique to probe its model Claude, so it’s a genuine discovery.  Sometimes these words keep track of where the LLM has got to in a particular task, sometimes they look more like flashes of recognition (for example, “protein” might pop up when you give an LLM only the letters of a protein sequence), and sometimes they represent a kind of internal commentary on the model’s decision-making. In my favorite example, Claude decided to cheat on a coding test when the word “panic” appeared. Anthropic also found that LLMs are able to describe and manipulate the words in this space. So somehow they seem to be making use of it.  Let’s step back for a second. I don’t think of large language models as simple, but they’re also not magic. There’s a bunch of math that learns relationships between words, right? So why is it so hard to “peer” into an LLM to know what’s going on? Yeah, they’re not magic! I think the fact we don’t fully understand them plays into the mythmaking. And it’s worth noting that the whole narrative that Anthropic is leaning into here—that they’ve built this really mysterious technology, but don’t worry, because they’re also the ones to figure it out—very much fits with the company’s vibe. [See how Anthropic warned that its new models were so good at coding they posed a global cybersecurity risk, only for the US government to shut them down shortly thereafter.] So yes: LLMs are just math. And yet it’s vastly complex math. Not only are today’s LLMs made out of hundreds of billions of numbers, but running them triggers a cascade of millions and millions of calculations. I wrote last year that if you printed out even a medium-size LLM on pieces of paper, it would cover a city the size of San Francisco.  It’s impossible to make sense of any of that math without specialist tools that highlight specific parts of an LLM at specific times. You need to know where to look and how to look. And building those tools requires understanding something of that complex math in the first place.  You’ve written elsewhere about this concept of studying LLMs the way one might study an organism’s brain. Is it fair to use “brain-like” terms when talking about how an LLM works? I don’t love using those kinds of terms. LLMs are not brains. Talking like this is misleading because it can suggest that LLMs are capable of more human-like things than they are or that we can make assumptions about how they might behave that we shouldn’t. The whole anthropomorphization thing is also tied up with a bunch of strong ideological positions about what this technology is and what it’s going to be.  But at the same time, we lack a good alternative vocabulary for talking about what these models are doing. I can understand why people reach for words like “think” and “understand” and “brain-like”—they’re convenient shorthand.  Anthropic compares this new space it found inside LLMs to the space that some neuroscientists think our brains use to keep track of conscious thoughts. I asked the company how seriously we should take that comparison and it said in a statement: “Drawing these analogies was helpful to us in designing our experiments, as they allowed us to make many non-obvious experimental predictions about the J-space that turned out to be true. At the same time, it’s important to note that there are some important differences between the J-space (and language models in general) and the human brain, so we don’t mean to claim there’s a perfect correspondence.”  What’s a problem in AI that this new concept of the J-space might be used to solve? Anthropic

In this tutorial, we build an autonomous data science agent around DeepAnalyze-8B and run it. We begin by preparing a stable runtime, installing the required machine-learning dependencies, and loading the DeepAnalyze tokenizer and model in 4-bit mode to keep the workflow practical on limited GPU memory. We then create a sandboxed execution environment that allows the model to generate Python code, execute it safely, observe the results, and continue its analysis in an agentic loop. By the end of the workflow, we give the agent a realistic multi-file e-commerce workspace and let it clean, join, analyze, visualize, and summarize the data as a structured analyst-grade report. Installing DeepAnalyze-8B Runtime Dependencies Copy CodeCopiedUse a different Browser import os, sys, subprocess os.environ[“MPLBACKEND”] = “Agg” def _pip(*args): subprocess.check_call([sys.executable, “-m”, “pip”, “install”, “-q”, *args]) _SETUP_FLAG = “/content/.da_ready” if not os.path.exists(_SETUP_FLAG): print(“Installing dependencies (one-time). The runtime will RESTART; ” “just re-run this cell afterwards.n”) _pip(“-U”, “transformers>=4.44”, “accelerate>=0.30”, “bitsandbytes>=0.43”) _pip(“sentencepiece”) _pip(“openpyxl”) _pip(“–force-reinstall”, “numpy==2.0.2”) open(_SETUP_FLAG, “w”).close() print(“nDependencies ready. Restarting runtime now…”) os.kill(os.getpid(), 9) We start by preparing the Colab runtime with the required machine-learning dependencies for DeepAnalyze-8B. We install the transformer, acceleration, quantization, tokenizer, and spreadsheet libraries without disturbing the broader notebook workflow. We also pin NumPy and restart the runtime once to keep the environment clean and stable for the next execution. Loading DeepAnalyze-8B in 4-Bit Mode Copy CodeCopiedUse a different Browser import re, io, glob, time, signal, contextlib, warnings, traceback from threading import Thread import numpy as np, pandas as pd import torch from transformers import (AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TextIteratorStreamer) warnings.filterwarnings(“ignore”) MODEL_ID = “RUC-DataLab/DeepAnalyze-8B” USE_4BIT = True COMPUTE_DT = torch.float16 assert torch.cuda.is_available(), ( “No GPU detected. In Colab: Runtime -> Change runtime type -> GPU.”) print(“GPU:”, torch.cuda.get_device_name(0), “| NumPy:”, np.__version__) print(“nLoading tokenizer & model (first run downloads ~16GB, be patient)…”) tok = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True) if tok.pad_token_id is None: tok.pad_token = tok.eos_token bnb = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type=”nf4″, bnb_4bit_compute_dtype=COMPUTE_DT, bnb_4bit_use_double_quant=True, ) if USE_4BIT else None model = AutoModelForCausalLM.from_pretrained( MODEL_ID, quantization_config=bnb, device_map=”auto”, torch_dtype=COMPUTE_DT, low_cpu_mem_usage=True, trust_remote_code=True, ) model.eval() print(“Model loaded. VRAM used: %.1f GB” % (torch.cuda.memory_allocated()/1e9)) We import the main libraries, configure the DeepAnalyze-8B model, and verify that a GPU is available in Colab. We load the tokenizer and prepare 4-bit quantization so the model can fit more comfortably on a T4 GPU. We then load the model in evaluation mode and confirm GPU memory usage before moving on to the agent logic. Building the Sandboxed Code Executor Copy CodeCopiedUse a different Browser class CodeSandbox: def __init__(self, timeout=120, max_chars=6000): self.ns = {“__name__”: “__main__”} self.timeout, self.max_chars = timeout, max_chars def _run(self, code): with contextlib.redirect_stdout(io.StringIO()) as out, contextlib.redirect_stderr(io.StringIO()) as err: exec(compile(code, “<cell>”, “exec”), self.ns) return out.getvalue() + err.getvalue() def execute(self, code): def _handler(signum, frame): raise TimeoutError(f”Execution exceeded {self.timeout}s”) prev = signal.signal(signal.SIGALRM, _handler) signal.alarm(self.timeout) try: out = self._run(code) result = out if out.strip() else “[Executed successfully, no stdout]” except Exception as e: tb = traceback.format_exc().splitlines() loc = next((l.strip() for l in tb if ‘”<cell>”‘ in l), “”) result = f”[Error]n{loc}n{type(e).__name__}: {e}”.strip() finally: signal.alarm(0) signal.signal(signal.SIGALRM, prev) if len(result) > self.max_chars: result = result[:self.max_chars] + “n…[output truncated]…” return result We define a sandboxed code executor that gives the agent a persistent Python namespace for running generated code. We capture standard output and error streams so that every execution result can be passed back into the reasoning loop. We also enforce a timeout and truncate long outputs to keep the autonomous workflow controlled and readable. Implementing the DeepAnalyze Agentic Loop Copy CodeCopiedUse a different Browser class DeepAnalyzeAgent: def __init__(self, model, tok, temperature=0.5, top_p=0.95): self.model, self.tok = model, tok self.temperature, self.top_p = temperature, top_p def _stream_generate(self, context, max_new_tokens): inputs = self.tok(context, return_tensors=”pt”, add_special_tokens=False).to(self.model.device) streamer = TextIteratorStreamer(self.tok, skip_prompt=True, skip_special_tokens=False) kwargs = dict( **inputs, max_new_tokens=max_new_tokens, do_sample=True, temperature=self.temperature, top_p=self.top_p, stop_strings=[“</Code>”], tokenizer=self.tok, streamer=streamer, pad_token_id=self.tok.pad_token_id, eos_token_id=self.tok.eos_token_id, ) Thread(target=self.model.generate, kwargs=kwargs).start() pieces = [] for chunk in streamer: pieces.append(chunk); print(chunk, end=””, flush=True) return “”.join(pieces) @staticmethod def _extract_code(delta): if “<Code>” in delta and “</Code>” not in delta: delta += “</Code>” m = re.search(r”<Code>(.*?)</Code>”, delta, re.DOTALL) if not m: return None code = m.group(1).strip() fenced = re.search(r”“`(?:python)?(.*?)“`”, code, re.DOTALL) return (fenced.group(1) if fenced else code).strip() def run(self, instruction, workspace, max_rounds=12, max_new_tokens=3072, exec_timeout=120): prompt = build_prompt(instruction, workspace) prefix = self.tok.apply_chat_template( [{“role”: “user”, “content”: prompt}], tokenize=False, add_generation_prompt=True) sandbox = CodeSandbox(timeout=exec_timeout) full, trace = prefix, [] cwd0 = os.getcwd(); os.chdir(workspace) try: for r in range(max_rounds): print(f”nn{‘=’*70}n ROUND {r+1}n{‘=’*70}”) delta = self._stream_generate(full, max_new_tokens) full += delta trace.append((“model”, delta)) if “<Answer>” in delta: print(“nn[Agent finished: <Answer> produced]”); break code = self._extract_code(delta) if code is None: print(“nn[Agent stopped: no further action]”); break output = sandbox.execute(code) print(f”nn— <Execute> —n{output}n— </Execute> —“) full += f”n<Execute>n{output}n</Execute>n” trace.append((“execute”, output)) else: print(f”nn[Reached max_rounds={max_rounds}]”) finally: os.chdir(cwd0) answer = “” if “<Answer>” in full: answer = full.split(“<Answer>”)[-1] answer = re.sub(r”</?Answer>”, “”, answer) answer = re.sub(r”<[｜|][^>]*?[｜|]>”, “”, answer).strip() return {“full”: full, “trace”: trace, “answer”: answer} We implement the DeepAnalyze agent loop, which streams model outputs, extracts the generated code, and executes it step by step. We allow the model to alternate between reasoning, coding, execution feedback, and final answering through special action tags. We maintain the full conversation trace so the agent can refine its analysis based on previous outputs and execution results. Running the E-Commerce Analysis Workspace Copy CodeCopiedUse a different Browser def _hsize(nbytes): for u in [“B”, “KB”, “MB”, “GB”]: if nbytes < 1024: return f”{nbytes:.1f}{u}” nbytes /= 1024 return f”{nbytes:.1f}TB” def build_prompt(instruction, workspace): exts = (“.csv”, “.xlsx”, “.xls”, “.json”, “.xml”, “.yaml”, “.yml”, “.txt”, “.md”, “.tsv”, “.db”, “.sqlite”) files = sorted(f for f in os.listdir(workspace) if f.lower().endswith(exts)) lines = [f’File {i+1}: {{“name”: “{f}”, “size”: “‘ f'{_hsize(os.path.getsize(os.path.join(workspace, f)))}”}}’ for i, f in enumerate(files)] return f”# Instructionn{instruction}nn# Datan” + “n”.join(lines) WORKSPACE = “/content/da_workspace” os.makedirs(WORKSPACE, exist_ok=True) rng = np.random.default_rng(42); N = 2500 categories = [“Electronics”, “Home”, “Fashion”, “Books”, “Toys”] dates = pd.to_datetime(“2024-01-01″) + pd.to_timedelta(rng.integers(0, 365, N), unit=”D”) tx = pd.DataFrame({ “order_id”: np.arange(100000, 100000 + N), “date”: dates, “customer_id”: rng.integers(1, 601, N), “category”: rng.choice(categories, N, p=[.3, .2, .25, .15, .1]), “region”: rng.choice([“North”, “South”, “East”, “West”], N), “quantity”: rng.integers(1, 6, N), “unit_price”: np.round(rng.gamma(3, 12, N) + 5, 2), “discount”: np.round(rng.choice([0, .05, .1, .15, .2], N), 2), }) tx[“revenue”] = np.round(tx.quantity *

Automatic Music Transcription (AMT) converts an audio recording into symbolic notes, usually MIDI. Single-instrument transcription already works reasonably well. However, transcribing a full multi-instrument mix stays difficult. Kyutai and Mirelo team now release MuScriptor to close that gap. It is an open-weight model trained on real, multi-instrument recordings across many genres. This article explains how MuScriptor works, what the benchmarks show, and how to run it. What is MuScriptor? At its core, MuScriptor is a decoder-only Transformer for music transcription. First, it reads a mel-spectrogram of a short audio segment. Then it autoregressively predicts MIDI-like tokens for pitch, timing, and instrument. In effect, transcription becomes a language-modeling task, following the MT3 tokenization scheme. The release ships three weight variants on Hugging Face. Their sizes are small (103M), medium (307M, default), and large (1.4B). The inference code uses the MIT license. The weights use CC BY-NC 4.0, so commercial use is restricted. How the Three-Stage Pipeline Works MuScriptor’s main idea is data, not architecture. Accordingly, training moves through three stages, and each builds on the last. Pre-training uses D_Synth, roughly 1.45M MIDI files. An on-the-fly pipeline synthesizes them during training. Augmentations include pitch shifting, tempo changes, velocity adjustment, and instrument randomization. Over 250 soundfonts plus random detuning yield near-infinite audio realizations. Fine-tuning uses D_Real, an internal set of 170,000 recordings. Together they total more than 11,000 hours with aligned note annotations. Most alignments come from audio-symbolic synchronization using interpolation and dynamic time warping. Poor pairs are filtered by warping distance and a maximum time-dilation factor. Reinforcement learning post-training uses D_RL, 300 manually verified tracks. The team applies a GRPO-like method combining REINFORCE with group-relative advantage normalization. The reward sums three F-scores: onset, frame, and offset. As a result, the model learns to favor cleaner transcriptions. Transcribe</button> </div> </div> <div class=”rollwrap”> <svg class=”roll” id=”roll” viewBox=”0 0 720 300″ preserveAspectRatio=”xMidYMid meet” role=”img” aria-label=”Piano roll transcription”></svg> </div> <div class=”legend”> <span><i style=”background:#2563EB”></i>True positive (detected)</span> <span><i style=”background:#16A34A”></i>False negative (missed)</span> <span><i style=”background:#DC2626″></i>False positive (wrong)</span> </div> <div class=”grid”> <div class=”metrics”> <div class=”metric”> <small>Onset F1</small> <div class=”val” id=”mOnset”>—</div> <div class=”baseline” id=”bOnset”></div> <div class=”metricbar”><i id=”barOnset”></i></div> </div> <div class=”metric”> <small>Multi F1</small> <div class=”val” id=”mMulti”>—</div> <div class=”baseline” id=”bMulti”></div> <div class=”metricbar”><i id=”barMulti”></i></div> </div> </div> <div class=”stream” id=”stream”> <div class=”h”>Event stream · model.transcribe()</div> <div class=”ln” style=”opacity:.6″>Press Transcribe to stream note events…</div> </div> </div> <p class=”note” id=”stageNote”></p> </div> <div class=”foot”> <span>Note pattern is illustrative. F1 scores are real, from the MuScriptor paper (1.3B model on D_Test).</span> <span>Built by <b>Marktechpost</b></span> </div> </div> <script> (function(){ var SVG=”http://www.w3.org/2000/svg”; var roll=document.getElementById(“roll”); var W=720,H=300,PADL=64,PADR=14,PADT=14,PADB=26; var DUR=10; // seconds shown var rows=[ {name:”Drums”,inst:”drums”,y:0}, {name:”E-Bass”,inst:”e_bass”,y:1}, {name:”Dist. E-Gtr”,inst:”distorted_e_guitar”,y:2}, {name:”Ac. Piano”,inst:”acoustic_piano”,y:3}, {name:”Voice”,inst:”voice”,y:4}, {name:”Strings”,inst:”string_ensemble”,y:5} ]; var NR=rows.length; var rowH=(H-PADT-PADB)/NR; function tx(t){return PADL+(t/DUR)*(W-PADL-PADR);} function ry(r){return PADT+r*rowH;} // Illustrative ground-truth notes: [row, start, dur, rank(0=easy..1=hard)] var GT=[ [0,0.3,0.18,0.1],[0,0.8,0.18,0.15],[0,1.3,0.18,0.2],[0,1.8,0.18,0.1],[0,2.4,0.18,0.25],[0,3.0,0.18,0.2],[0,3.6,0.18,0.3],[0,4.2,0.18,0.2],[0,4.9,0.18,0.4],[0,5.5,0.18,0.3],[0,6.2,0.18,0.5],[0,6.9,0.18,0.4],[0,7.6,0.18,0.6],[0,8.3,0.18,0.5],[0,9.0,0.18,0.7], [1,0.4,0.8,0.2],[1,1.6,0.8,0.25],[1,3.0,0.9,0.35],[1,4.4,0.8,0.4],[1,5.8,0.9,0.5],[1,7.2,0.9,0.6],[1,8.6,0.9,0.7], [2,1.0,1.1,0.45],[2,2.6,1.0,0.55],[2,4.2,1.2,0.6],[2,6.0,1.1,0.7],[2,7.8,1.1,0.8], [3,0.6,0.7,0.3],[3,1.7,0.6,0.35],[3,2.9,0.7,0.4],[3,4.1,0.6,0.5],[3,5.3,0.7,0.55],[3,6.6,0.6,0.65],[3,8.0,0.8,0.75], [4,2.0,1.4,0.5],[4,4.0,1.5,0.6],[4,6.3,1.4,0.72],[4,8.4,1.2,0.85], [5,1.2,1.8,0.55],[5,3.6,1.9,0.68],[5,6.0,1.9,0.8],[5,8.2,1.6,0.9] ]; // Illustrative false positives available: [row,start,dur,rank] var FPS=[ [0,2.1,0.16,0.9],[0,5.9,0.16,0.7],[0,7.9,0.16,0.85], [1,2.4,0.6,0.8],[1,6.6,0.7,0.9], [2,3.7,0.9,0.85],[2,8.9,0.9,0.95], [3,3.5,0.5,0.9],[3,7.3,0.6,0.8], [4,3.5,0.9,0.9],[4,7.7,0.8,0.95], [5,5.1,1.2,0.88],[5,9.2,0.9,0.97] ]; // Real numbers from the paper (1.3B, DTest). recall/fpRate are illustrative thresholds. var STAGES={ synth:{onset:34.5,multi:16.2,onBase:26.1,recall:0.42,fp:0.85, note:”Trained only on synthetic MIDI. It finds coarse pitch activity, but misses many onsets and mislabels instruments.”}, real:{onset:54.4,multi:41.6,onBase:52.5,recall:0.78,fp:0.35, note:”Fine-tuning on 170k real recordings lifts every metric by roughly 20 points over synthetic-only training.”}, rl:{onset:60.4,multi:48.2,onBase:60.4,recall:0.90,fp:0.12, note:”GRPO-style RL post-training on 300 verified tracks reduces false negatives and sharpens onset timing.”} }; var current=”rl”, cond=true, playing=false, playhead=0, raf=null, streamed={}; function selectedRows(){ if(!cond) return rows.map(function(r){return r.y;}); // conditioning example: focus on the core rhythm section + piano return [0,1,2,3]; } function classify(stage){ var s=STAGES[stage]; var tp=[],fn=[],fp=[]; var sel=selectedRows(); GT.forEach(function(n){ if(cond && sel.indexOf(n[0])===-1) return; // hidden by conditioning var boost=cond?0.08:0; // conditioning nudges recall up (illustrative) if(n[3] <= s.recall+boost) tp.push(n); else fn.push(n); }); FPS.forEach(function(n){ if(cond && sel.indexOf(n[0])===-1) return; var fpr=cond?s.fp*0.7:s.fp; // conditioning trims spurious notes if(n[3] > (1-fpr)) fp.push(n); }); return {tp:tp,fn:fn,fp:fp}; } function el(tag,attrs){var e=document.createElementNS(SVG,tag);for(var k in attrs)e.setAttribute(k,attrs[k]);return e;} function drawGrid(){ while(roll.firstChild) roll.removeChild(roll.firstChild); var sel=selectedRows(); for(var r=0;r<NR;r++){ var active=sel.indexOf(r)!==-1; roll.appendChild(el(“rect”,{x:PADL,y:ry(r),width:W-PADL-PADR,height:rowH, fill:(r%2? “#FAFBFD”:”#FFFFFF”),opacity:active?1:0.4})); roll.appendChild(el(“line”,{x1:PADL,y1:ry(r),x2:W-PADR,y2:ry(r),stroke:”#EFF1F5″,”stroke-width”:1})); var lbl=el(“text”,{x:PADL-8,y:ry(r)+rowH/2+4,”text-anchor”:”end”,”font-size”:11, fill:active?”#14161C”:”#B6BCC7″,”font-weight”:active?600:500,”font-family”:”Inter,sans-serif”}); lbl.textContent=rows[r].name; roll.appendChild(lbl); } // time gridlines every 2s (segment markers) for(var t=0;t<=DUR;t+=2){ roll.appendChild(el(“line”,{x1:tx(t),y1:PADT,x2:tx(t),y2:H-PADB,stroke:”#E7E9EE”,”stroke-width”:1,”stroke-dasharray”:”2 4″})); var tl=el(“text”,{x:tx(t),y:H-9,”text-anchor”:”middle”,”font-size”:10,fill:”#9AA1AE”,”font-family”:”Inter,sans-serif”}); tl.textContent=t+”s”; roll.appendChild(tl); } roll.appendChild(el(“line”,{x1:PADL,y1:H-PADB,x2:W-PADR,y2:H-PADB,stroke:”#E7E9EE”,”stroke-width”:1})); } var noteLayer,headLine; function render(reveal){ drawGrid(); var c=classify(current); noteLayer=el(“g”,{}); roll.appendChild(noteLayer); function bar(n,color,opacity){ var x=tx(n[1]),w=Math.max(6,tx(n[1]+n[2])-tx(n[1])); var y=ry(n[0])+rowH*0.28,h=rowH*0.44; var vis=(!reveal)|| (n[1]<=playhead); var rect=el(“rect”,{x:x,y:y,width:w,height:h,rx:3,fill:color,opacity:vis?opacity:0}); rect.style.transition=”opacity .18s”; noteLayer.appendChild(rect); } c.fn.forEach(function(n){bar(n,”#16A34A”,0.55);}); c.fp.forEach(function(n){bar(n,”#DC2626″,0.8);}); c.tp.forEach(function(n){bar(n,”#2563EB”,0.95);}); headLine=el(“line”,{x1:tx(playhead),y1:PADT,x2:tx(playhead),y2:H-PADB,stroke:”#5B9A00″,”stroke-width”:2,opacity:reveal?0.9:0}); roll.appendChild(headLine); postSize(); } function setMetrics(){ var s=STAGES[current]; animateNum(“mOnset”,s.onset); animateNum(“mMulti”,s.multi); document.getElementById(“bOnset”).textContent=”baseline YourMT3+ 32.5″; document.getElementById(“bMulti”).textContent=”baseline YourMT3+ 21.9″; document.getElementById(“barOnset”).style.width=s.onset+”%”; document.getElementById(“barMulti”).style.width=(s.multi/60*100)+”%”; document.getElementById(“stageNote”).textContent=s.note; } function animateNum(id,to){ var e=document.getElementById(id),from=parseFloat(e.textContent)||0,st=null,dur=550; function step(ts){if(!st)st=ts;var p=Math.min(1,(ts-st)/dur); e.textContent=(from+(to-from)*(1-Math.pow(1-p,3))).toFixed(1); if(p<1)requestAnimationFrame(step);} requestAnimationFrame(step); } // event stream var stream=document.getElementById(“stream”); function resetStream(){stream.innerHTML='<div class=”h”>Event stream · model.transcribe()</div>’;streamed={};} function pushEvent(n,kind){ var pitchNames=[“C2″,”G2″,”E3″,”C4″,”A4″,”D5”]; var line=document.createElement(“div”);line.className=”ln”; var p=pitchNames[n[0]]||”C4″;var inst=rows[n[0]].inst; if(kind===”start”){ line.innerHTML='<span class=”st”>NoteStart</span> t=<span class=”pi”>’+n[1].toFixed(2)+’s</span> pitch=<span class=”pi”>’+p+'</span> inst=<span class=”in”>’+inst+'</span>’; }else{ line.innerHTML='<span class=”en”>NoteEnd</span> t=<span class=”pi”>’+(n[1]+n[2]).toFixed(2)+’s</span> (‘+inst+’)’; } stream.appendChild(line);stream.scrollTop=stream.scrollHeight; } function play(){ if(playing)return; playing=true; var btn=document.getElementById(“playBtn”);btn.disabled=true;btn.textContent=”● Transcribing…”; playhead=0; resetStream(); var c=classify(current); var visible=c.tp.concat(c.fp).sort(function(a,b){return a[1]-b[1];}); render(true); var t0=null,SPEED=DUR/4200; // ms mapping function frame(ts){ if(!t0)t0=ts; playhead=Math.min(DUR,(ts-t0)*SPEED); // reveal notes + emit events visible.forEach(function(n,i){ var key=”s”+i; if(n[1]<=playhead && !streamed[key]){streamed[key]=1; var rects=noteLayer.querySelectorAll(“rect”); pushEvent(n,”start”); setTimeout((function(nn){return function(){pushEvent(nn,”end”);};})(n),120); } }); // update opacities Array.prototype.forEach.call(noteLayer.querySelectorAll(“rect”),function(r){}); render(true); if(playhead<DUR){raf=requestAnimationFrame(frame);} else{playing=false;btn.disabled=false;btn.textContent=” Transcribe again”; headLine.setAttribute(“opacity”,”0″);postSize();} } raf=requestAnimationFrame(frame); } // controls document.getElementById(“stages”).addEventListener(“click”,function(e){ var b=e.target.closest(“button”);if(!b)return; Array.prototype.forEach.call(this.children,function(c){c.classList.remove(“on”);}); b.classList.add(“on”);current=b.getAttribute(“data-s”); playhead=DUR;render(false);setMetrics();postSize(); }); document.getElementById(“condToggle”).addEventListener(“click”,function(){ cond=!cond;this.classList.toggle(“on”,cond); playhead=DUR;render(false);postSize(); }); document.getElementById(“playBtn”).addEventListener(“click”,play); // pipeline shimmer var pnodes=document.querySelectorAll(“#pipe .node”),pi=0; setInterval(function(){ pnodes.forEach(function(n){n.classList.remove(“hot”);}); pnodes[pi].classList.add(“hot”);pi=(pi+1)%pnodes.length; },900); // resize to parent (WordPress embed) function postSize(){ try{var h=document.body.offsetHeight+40; window.parent.postMessage({muscriptorHeight:h},”*”);}catch(e){} } window.addEventListener(“resize”,function(){render(false);postSize();}); // init playhead=DUR;render(false);setMetrics();setTimeout(postSize,60);setTimeout(postSize,400); })(); </script> </body> </html> “> Performance For evaluation, the research team use D_Test, 372 held-out tracks with accurate annotations. They report instrument-agnostic metrics from the mir_eval library. Among them, Multi F1 is strictest, since it also requires the correct instrument. The table below traces each training stage against the YourMT3+ baseline, using the large (~1.3B) model. Model (D_Test) Onset F1 Frame F1 Offset F1 Drums F1 Multi F1 YourMT3+ (baseline) 32.5 45.5 17.8 41.4 21.9 MuScriptor · D_Synth 34.5 48.9 16.1 21.0 16.2 MuScriptor · D_Synth + D_Real 54.4 69.3 42.3 43.3 41.6 MuScriptor · D_Synth + D_Real + D_RL 60.4 73.3 49.0 50.2 48.2 Clearly, every stage improves results, and real data matters most. Synthetic-only training reaches competitive frame F1 but weak onset and multi scores. Adding D_Real then lifts all metrics by roughly 20 points. Finally, RL post-training reduces false negatives and sharpens onset timing.

In this tutorial, we explore TileGym GPU programming by building a practical Colab workflow that runs across different hardware conditions. We begin by probing the available CUDA environment, checking whether NVIDIA cuTile runs directly, and falling back to Triton when standard Colab GPUs lack the required cuTile stack. Through this setup, we learn the core tile-programming idea: instead of writing code for one thread at a time, we operate on entire data tiles, load them into the kernel, compute on them efficiently, and store the results back. We use this model to implement vector addition, fused GELU, row-wise softmax, tiled matrix multiplication, and flash attention, while comparing each result against PyTorch for correctness and benchmarking. CUDA Environment Probe Copy CodeCopiedUse a different Browser import os, sys, math, time, textwrap def rule(t=””): print(“n” + “=” * 78) if t: print(t) print(“=” * 78) rule(“0. ENVIRONMENT PROBE”) try: import torch except ImportError: print(“Installing torch …”) os.system(f”{sys.executable} -m pip install -q torch”) import torch HAS_CUDA = torch.cuda.is_available() DEV = “cuda” if HAS_CUDA else “cpu” cc = (0, 0) if HAS_CUDA: cc = torch.cuda.get_device_capability() print(f”GPU : {torch.cuda.get_device_name(0)}”) print(f”Compute capability : {cc[0]}.{cc[1]}”) print(f”Torch CUDA runtime : {torch.version.cuda}”) print(f”Driver / torch : {torch.__version__}”) else: print(“No CUDA GPU found. In Colab: Runtime -> Change runtime type -> GPU (T4).”) print(“The tutorial will still run its correctness math on CPU where possible.”) CUTILE_HW_OK = HAS_CUDA and cc[0] >= 8 CUDA_MAJOR = int((torch.version.cuda or “0”).split(“.”)[0]) if HAS_CUDA else 0 CUTILE_TOOLKIT_OK = CUDA_MAJOR >= 13 rule(“1. ATTEMPTING REAL cuTile (NVIDIA CUDA Tile) BACKEND”) ct = None CUTILE_READY = False if CUTILE_HW_OK and CUTILE_TOOLKIT_OK: try: import cuda.tile as ct CUTILE_READY = True print(“cuda.tile is already importable.”) except Exception: print(“Installing cuda-tile[tileiras] (this can take a while)…”) os.system(f”{sys.executable} -m pip install -q ‘cuda-tile[tileiras]’ cupy-cuda13x”) try: import cuda.tile as ct CUTILE_READY = True except Exception as e: print(“cuTile import still failed:”, repr(e)) else: reasons = [] if not HAS_CUDA: reasons.append(“no CUDA GPU”) if HAS_CUDA and cc[0] < 8: reasons.append(f”compute capability {cc[0]}.{cc[1]} < 8.0 (Turing/T4 unsupported)”) if not CUTILE_TOOLKIT_OK: reasons.append(f”CUDA {torch.version.cuda} < 13.1 required by tileiras”) print(“Skipping real cuTile install because:”, “; “.join(reasons) + “.”) print(“This is expected on a standard Colab T4 — we fall back to Triton below,”) print(“which teaches the exact same tile-based programming model.”) if CUTILE_READY: BACKEND = “cutile” else: try: import triton, triton.language as tl BACKEND = “triton” if HAS_CUDA else “torch” except ImportError: if HAS_CUDA: print(“Installing triton …”) os.system(f”{sys.executable} -m pip install -q triton”) try: import triton, triton.language as tl BACKEND = “triton” except Exception: BACKEND = “torch” else: BACKEND = “torch” rule(f”ACTIVE EXECUTION BACKEND: {BACKEND.upper()}”) print({ “cutile”: “Running NVIDIA cuTile kernels on your Ampere+/CUDA13 GPU. Nice hardware!”, “triton”: “Running Triton tile kernels on your GPU (the standard Colab path).”, “torch”: “No usable GPU kernel backend; showing reference math on CPU only.”, }[BACKEND]) print(textwrap.dedent(“”” —————————————————————— SIMT (classic CUDA) | TILE model (cuTile / Triton) —————————————————————— You write code for ONE | You write code for ONE BLOCK that thread. You compute a global | owns a whole TILE (e.g. 1024 elems index, bounds-check it, and | or a 128×128 sub-matrix). You load touch a single element. | the tile, do math on the WHOLE tile, | store it. The compiler maps the tile C[i] = A[i] + B[i] | onto threads / tensor cores for you. —————————————————————— cuTile primitives: ct.bid(0), ct.load(…), ct.store(…), a @ b, ct.launch Triton primitives: tl.program_id, tl.load, tl.store, tl.dot, grid[…] Same idea, two spellings. Below, every kernel is shown in BOTH. “””)) CUTILE_SOURCE = { “vector_add”: ”’ import cuda.tile as ct @ct.kernel def vector_add(a, b, c, tile_size: ct.Constant[int]): pid = ct.bid(0) a_tile = ct.load(a, index=(pid,), shape=(tile_size,)) b_tile = ct.load(b, index=(pid,), shape=(tile_size,)) ct.store(c, index=(pid,), tile=a_tile + b_tile) ”’, “matmul”: ”’ import cuda.tile as ct @ct.kernel def matmul(A, B, C, K: ct.Constant[int], BM: ct.Constant[int], BN: ct.Constant[int], BK: ct.Constant[int]): m, n = ct.bid(0), ct.bid(1) acc = ct.zeros((BM, BN), dtype=ct.float32) for k in range(ct.cdiv(K, BK)): a = ct.load(A, index=(m, k), shape=(BM, BK)) b = ct.load(B, index=(k, n), shape=(BK, BN)) acc = a @ b + acc ct.store(C, index=(m, n), tile=acc) ”’} We begin by setting up the environment, importing the required libraries, and checking whether CUDA is available on the current runtime. We inspect the GPU capabilities, CUDA version, and PyTorch setup to determine whether the real cuTile backend is usable. We then select the active execution backend, explain the tile programming model, and store reference cuTile kernel source strings for comparison. Defining Triton Kernels Copy CodeCopiedUse a different Browser if BACKEND == “triton”: @triton.jit def _vadd_kernel(a_ptr, b_ptr, c_ptr, n, BLOCK: tl.constexpr): pid = tl.program_id(0) offs = pid * BLOCK + tl.arange(0, BLOCK) mask = offs < n a = tl.load(a_ptr + offs, mask=mask) b = tl.load(b_ptr + offs, mask=mask) tl.store(c_ptr + offs, a + b, mask=mask) @triton.jit def _fused_gelu_kernel(x_ptr, w_ptr, b_ptr, o_ptr, n, BLOCK: tl.constexpr): pid = tl.program_id(0) offs = pid * BLOCK + tl.arange(0, BLOCK) mask = offs < n x = tl.load(x_ptr + offs, mask=mask) w = tl.load(w_ptr + offs, mask=mask) b = tl.load(b_ptr + offs, mask=mask) h = x * w + b c = 0.7978845608028654 z = c * (h + 0.044715 * h * h * h) e = tl.exp(-2.0 * z) tanh = (1.0 – e) / (1.0 + e) g = 0.5 * h * (1.0 + tanh) tl.store(o_ptr + offs, g, mask=mask) @triton.jit def _softmax_kernel(x_ptr, o_ptr, stride, n_cols, BLOCK: tl.constexpr): row = tl.program_id(0) cols = tl.arange(0, BLOCK) mask = cols < n_cols ptr = x_ptr + row * stride + cols x = tl.load(ptr, mask=mask, other=-float(“inf”)) x = x – tl.max(x, axis=0) num = tl.exp(x) den = tl.sum(num, axis=0) tl.store(o_ptr + row * stride + cols, num / den, mask=mask) @triton.jit def _matmul_kernel(A, B, C, M, N, K, sam, sak, sbk, sbn, scm, scn, BM: tl.constexpr, BN: tl.constexpr, BK: tl.constexpr): pid_m = tl.program_id(0) pid_n = tl.program_id(1) offs_m = pid_m * BM + tl.arange(0, BM) offs_n = pid_n * BN + tl.arange(0, BN) offs_k = tl.arange(0, BK) a_ptr = A + offs_m[:, None] * sam + offs_k[None, :] * sak b_ptr

arXiv:2607.08346v1 Announce Type: new Abstract: Form 8-K filings are the primary channel through which U.S. public companies disclose material events, but the SEC item codes attached to them are coarse: a single item spans routine administrative changes and chief executive departures, and many of the most market-moving disclosures fall into a catch-all item. Large language models make fine-grained labelling feasible at corpus scale, but only if the labels can be traced to the source text and shown to be reliable. We present a two-stage system that tags 8-K disclosures against a three-tier taxonomy of 119 event types. The first stage constrains output to valid taxonomy entries and anchors every tag to a verbatim quote via fuzzy n-gram validation; the second re-grades each cited quote against the category definition to produce a quality score. Applying the system to 292,984 filings from 2022 to 2026 yields 601,088 grounded event tags, which we release. Over 5,125 stratified tags, an LLM judge finds precision rises monotonically with the quality score, from 12% to 96%, while unsupported tags fall from 8% to near zero. Ablation shows the score is calibrated only when assigned in a dedicated second pass. An event study on unsigned abnormal returns confirms, without any language model, that the taxonomy separates economically distinct events sharing an item code.