标签：#m

I started this project because an LLM annoyed me. I gave a very strong model 322 , a small Dota 2 drafting game. The choices looked like the kind of work a computer should enjoy: repeated packs of players and heroes, visible ratings, familiarity scores, chemistry, rerolls and a simulated tournament at the end. I was disappointed by how well the LLM did. I am not a Dota expert, and I had only started watching it occasionally again during the previous six months or year. I still seemed to be doing better. The interesting engineering question was not how to write a longer prompt. It was how to replace the card-by-card language-model judgement with a deterministic policy, then test that policy without confusing improvement with luck. A stochastic benchmark needs shared randomness The browser history gave us a useful irritation and almost no reliable comparison. My earlier manual record contained 50 runs with a 14% title rate. The LLM won once in nine attempts. Putting 14% beside 11% looks temptingly quantitative, but the random offers, rejected packs and opponent fields were not preserved. The samples were small, unpaired and produced under different choices. That is not a model benchmark. It is a reason to build one. The offline solver generated every random choice from indexed tapes. Policy A and policy B received the same player offers, hero samples, field candidates and tournament randomness for a given episode. We could then compare the paired result: did the new policy win this exact episode where the old policy lost it? This is the common-random-numbers idea in a practical form. Sharing the luck removes a large amount of noise that has nothing to do with the policy change. Keep the simulator separate from the policy Before evaluating a strategy, we reproduced the game. The public client and seven data files were frozen with SHA-256 hashes. Draft legality, automatic hero allocation, chemistry, scoring and the tournament were ported into a deterministic Python engi

An algorithmic trading platform doesn't operate in isolation it responds to the changing conditions of the financial markets. One of the biggest factors affecting automated trading performance is the market session. Liquidity, volatility, trading volume, and price movements can vary significantly throughout the trading day, influencing how an algorithmic trading platform executes trades. Understanding how different market sessions impact automated trading can help traders choose the right strategies, manage risk more effectively, and improve overall trading performance. What Are Market Sessions? A market session refers to a specific period during which a stock exchange is open for trading. In India, the National Stock Exchange (NSE) and Bombay Stock Exchange (BSE) follow a structured trading schedule that includes the pre-open session, regular trading hours, and post-closing session. Each session has unique market characteristics, making it important for traders to understand how their automated strategies may behave during these periods. Why Market Sessions Matter in Algorithmic Trading An algorithmic trading platform follows predefined rules, but the market environment changes throughout the day. A strategy that performs well during high-volume periods may struggle when trading activity is low. Market sessions influence several key factors, including: Trading volume Market liquidity Price volatility Bid-ask spreads Order execution quality Recognizing these differences allows traders to build strategies that are better suited to specific market conditions. Pre-Open Session The pre-open session is used to determine the opening price of securities before regular trading begins. During this period: Orders are collected but not executed immediately. Prices may fluctuate as the market discovers the opening level. Liquidity can be limited. Large overnight news events may influence price movements. Most intraday automated strategies are designed to become active only afte

NumPy (Numerical Python) is a foundational open-source Python library for numerical and mathematical computation. It introduces the N-dimensional array ( ndarray ), a high-performance data structure for storing and manipulating large datasets efficiently. NumPy forms the computational foundation of the Python data-science ecosystem; major libraries such as Pandas, SciPy, scikit-learn, and TensorFlow build directly upon it. This tutorial is designed to provide a concise yet practical overview of NumPy and to support day-to-day technical work through clear, task-oriented examples. Key characteristics High performance: NumPy operations are implemented in highly optimised C, enabling many numerical workloads to run substantially faster than equivalent operations on standard Python lists. Vectorisation: NumPy reduces reliance on explicit Python loops by applying operations across entire arrays in a single expression. Memory efficiency: NumPy arrays store homogeneous data in contiguous memory blocks, typically reducing memory overhead relative to Python lists. Core features and capabilities NumPy provides a broad suite of tools for numerical computation, including: Multidimensional arrays: Creation and manipulation of 1D vectors, 2D matrices, and higher-dimensional structures. Broadcasting: Arithmetic operations between arrays of different, but compatible, shapes. Linear algebra: Built-in routines for matrix multiplication, determinants, inverses, and systems of linear equations. Random number generation: Utilities for generating random samples from common statistical distributions. Mathematical functions: Fast element-wise operations for trigonometric, logarithmic, exponential, and statistical calculations (for example, mean, median, and standard deviation). Python lists vs NumPy ndarrays Python lists can store heterogeneous data types (for example, strings, integers, and objects) in a single container. This flexibility is useful, but lists are comparatively inefficient

ElevenLabs has expanded ElevenAgents into a broader enterprise automation platform built around the full lifecycle of an AI agent: defining workflow-driven behavior, testing changes, deploying across customer channels, and improving performance in production. The most recent addition, ElevenAgents Spotlight , monitors voice and chat conversations in real time and provides recommendations intended to help teams improve agent outcomes. In its official ElevenAgents Spotlight announcement , ElevenLabs describes Spotlight as an observation and improvement layer for production agents . It is designed to review every conversation, organize interactions by topic, evaluate quality against criteria written in plain language, and surface context-aware suggestions. Combined with Procedures, Experiments, and Versioning, the release set gives enterprises a more structured way to operate AI agents beyond initial deployment. Spotlight adds continuous production feedback Spotlight is aimed at a common operational problem with customer-facing AI agents: a system can appear ready in testing but encounter unexpected patterns, failure modes, or shifts in customer sentiment after it reaches live traffic. Rather than requiring teams to manually sample conversations, Spotlight analyzes production voice and chat interactions as they occur. The platform can automatically group conversations by topic and track metrics including success rate and sentiment . Teams can define evaluations in plain language to score the quality of interactions against their own standards. That matters because a useful agent evaluation may depend on a company's specific process, such as whether the agent followed an escalation policy or collected required information, rather than a single generic measure of response quality. Spotlight also includes anomaly detection for changes in key metrics. Its integration support for observability tools such as Datadog, Grafana, and OpenTelemetry means the agent data can fit in

Major publishers are increasingly limiting OpenAI's GPTBot from accessing their reporting, marking a broader shift in how news organizations assert control over content used for AI training. The BBC and The Guardian list GPTBot as disallowed in their robots.txt policies, while The New York Times has also prohibited scraping for AI training and development without explicit permission in its terms of service. The development matters because web crawling has long been a route to assembling large training datasets. When high-profile publishers restrict access at the source, AI developers face a more constrained and more clearly governed data environment. The issue is not simply whether a crawler can retrieve a page. It is increasingly about permission, licensing and accountable data provenance . The Guardian's published robots.txt directives provide a direct example of this approach. The file disallows GPTBot alongside a broader set of bots, signaling that the publisher does not want its content scraped for AI training or data aggregation. What the publisher blocks change Robots.txt is a machine-readable file that tells web crawlers which parts of a site they are permitted to access. For AI-related crawlers, it has become a practical opt-out mechanism. Publishers are pairing that technical control with contractual restrictions and discussions around licensing, rather than relying on informal expectations about how online content may be reused. The actions documented across major publishers are not identical, but they point in the same direction: indiscriminate collection of publisher content is becoming harder to justify and operationalize . The distinction is important because some publisher policies differentiate between crawlers used for model training and systems used for retrieval, indexing or other purposes. Publisher Documented action Relevant implication The Guardian Its robots.txt disallows GPTBot and a broader set of bots. Signals restrictions on AI training o

Semrush has updated its keyword research workflow with AI features designed to turn work that could historically take days into minutes. The key distinction is not AI generation alone: Semrush is combining AI with its existing keyword data and domain-level context, aiming to give marketers faster recommendations without relying on unverified search-volume outputs. The official Semrush announcement describes changes across Keyword Overview, Keyword Magic Tool, and Keyword Strategy Builder. The updates include a domain-personalized Personal Keyword Difficulty (PKD) metric, Topical Authority analysis, and a redesigned planning tool previously called Keyword Manager. Semrush says the capabilities are included with paid subscriptions. For SEO teams, the practical development is a shift from treating keyword research as a collection of isolated volume and difficulty checks toward a workflow that evaluates whether a topic fits a specific website. That can reduce manual steps in discovery and planning, while retaining a connection to the tool's underlying data. What Semrush changed in its keyword research workflow The new workflow applies a combined data-and-AI approach to thematic relevance. Semrush says it analyzes the relationship between a target topic and a domain's core topics, then surfaces that context in the product interface. This matters because the same keyword can have different strategic value for different sites, depending on their established subject coverage. The updates cover three connected stages of research: Keyword evaluation: Personal Keyword Difficulty adds domain-specific context to keyword difficulty assessment. Topic relevance: Topical Authority is intended to show how closely a topic aligns with a domain's core areas. Planning: Keyword Strategy Builder has been redesigned to support automated keyword and content planning workflows. Workflow area Earlier approach Semrush AI-driven update Keyword difficulty Keyword-level evaluation Personal Keyword

Having used LLMs to assist with reviews, and also having received reviews that appear to rely heavily on LLM-generated text, I have noticed two recurring problems. 1. The endless search for uncontrolled variables LLMs are very good at identifying additional variables that were not explicitly controlled. The problem is that many of these variables have little realistic chance of changing the paper’s main conclusion. For any experiment, it is possible to generate an almost unlimited list of potential confounders. Suppose a study finds that trees treated with fertilizer A grow better than trees treated with fertilizer B. An LLM can ask whether rainfall was perfectly controlled, whether the distribution of grass around the trees was considered, or whether wind, temperature, soil microorganisms, and countless other factors were isolated. Each question may look logically valid in isolation. But the real issue is not whether a variable exists. The issue is whether it is sufficiently important and plausible to threaten the conclusion. LLMs are generally poor at making this prioritization. They often convert minor residual uncertainty into what sounds like a serious methodological weakness. This becomes especially harmful when reviewers copy such outputs directly into their reviews without independently assessing their importance. Authors are then forced to spend the rebuttal addressing an endless series of technically possible but practically insignificant concerns. A review should not ask whether every imaginable variable has been controlled. It should ask whether the remaining uncertainty materially weakens the central claim. 2. LLM reviews are often overly abstract Another common problem is criticism at the level of an entire research field rather than a specific prior method. For example, an LLM may claim that a proposed method is “not sufficiently different from methods in Transformer” without identifying a concrete paper, objective, architecture, or learning relation

Part 1 was about waiting well. This one is about not waiting at all, and about a couple of mistakes I...

Version 5.0.0 of eslint-rspack-plugin has been released as a pure ESM package, aligning with the Rspack ecosystem and removing its CommonJS build. The plugin continues to integrate ESLint in the build process but may affect build times. Users are advised to consider separate linting commands for efficiency. The project is open source and available via npm. By Daniel Curtis

Problem Description Merge multiple structurally similar tables with different column names into a wide table using full outer joins by common ID. Four tables have similar structures, each with two fields. The fields have the same meaning but different names (id, id2, id3, id4 all represent ID). The goal is to merge the four tables into single rows by ID, with each ID appearing in exactly one row. When an ID is absent in a table, the corresponding columns take NULL. Source Data T1 table: T2 table: T3 table: T4 table: * Expected Result * For example, ID=555 appears in both T1 and T2 but not in T3 or T4, so id, colA, id2, colB have values, while id3/colC/id4/colD are NULL. ID=222 only appears in T3, so only id3 and colC have values; all other columns are NULL. ID=10 appears in T2 and T4 but not in T1 or T3, so id2, colB, id4, colD have values; all other columns are NULL. SQLazy Step-by-Step Implementation Core Idea: First use derive to unify the ID column names of each table to ID_main, making subsequent merging easier. Then start from the first table and perform full outer joins one by one: use join to full outer join the current result with the next table on ID_main, then use derive and nvl to merge the new ID into the ID_main column, appending tables one by one to get the final result. [ Click to run this example online ] The steps are explained below. Steps 1-4: Unify ID Column Names Across Tables derive id as ID_main, id, colA Use derive on T1-T4 to rename their respective ID column names (id/id2/id3/id4) uniformly to ID_main. Step 5: Full Outer Join T1 and T2 join ID_main; with t2; ID_main; take id2, colB; full Use the join function to full outer join t1 and t2 on ID_main. Step 6: Merge NULLs in ID Column derive nvl(ID_main, id2) as ID_main, id, colA, id2, colB If a record comes from t2 but is not present in t1, its ID_main is NULL. This step assigns t2.id2 to ID_main in such records, ensuring the ID_main column always has a value. Different SQL implementations u

A product can look healthy while its AI feature quietly loses money on every successful user action. The demo feels fast, the answers look useful, and usage is growing. Then the bill lands, and nobody can explain which workflow, tenant, prompt, model route, or retry loop consumed the margin. That is the practical value of inference efficiency ratio . It gives builders a simple question to answer before scaling an AI workflow: for every dollar spent on production inference, how much product value did the system create? This article shows how to instrument that answer without turning your codebase into a finance spreadsheet. Working definition: Inference Efficiency Ratio = AI-attributed product revenue / production inference cost You do not need a huge finance team to use it. You need clean events, honest cost attribution, and a dashboard that makes bad unit economics visible early. Why builders are talking about inference efficiency now Recent AI news has a clear pattern: agents are doing more real work, open-weight models are pushing prices down, and teams are moving from demos into production operations. At the same time, builders are asking harder questions about cost, security, reliability, and whether AI workflows can survive real customer usage. The current signals are hard to miss: Hacker News discussions are focused on open-source AI infrastructure, cloud coding agents, production access, and model price-performance. Developer content is moving from "try this model" toward "operate this workflow safely and cheaply." AI cost writing is shifting from token price alone to product-level unit economics. Multi-agent systems, web context pipelines, and voice agents are increasing the number of hidden model calls per user action. The gap: many articles explain token counting, caching, or model routing. Fewer show how to connect those details to product margin in a way a solo builder can implement. That is the angle here. What inference efficiency ratio actually measu

The European Union's voluntary General-Purpose AI Code of Practice gives providers of general-purpose AI models a practical framework for supporting compliance with the EU AI Act. Finalised in July 2025, the code addresses transparency, copyright, and safety and security. Its public signatory list includes major AI and technology companies, but official EU material does not support claims that roughly 190 organisations have signed the GPAI code. The distinction matters for companies assessing AI suppliers. Signing the code can signal engagement with the EU's emerging governance expectations, but it is not a substitute for examining a provider's specific commitments, documentation, and product-level controls. The European Commission describes the code as a voluntary instrument, and its official GPAI Code of Practice page states that the signatory process and public information continue to be updated. What the GPAI Code of Practice covers The code is designed for providers of general-purpose AI models, a category that can include models used across multiple downstream applications. Rather than creating a separate legal regime, it is intended to help providers demonstrate how they can meet relevant AI Act obligations . Its three chapters cover different aspects of provider responsibility: Transparency: commitments related to information and documentation that can help downstream providers understand and use general-purpose AI models appropriately. Copyright: measures intended to address copyright-related obligations for providers of general-purpose AI models. Safety and security: commitments focused on managing risks associated with the most capable models, including systemic-risk considerations where applicable. Code chapter Primary focus Why it matters to AI buyers Transparency Provider information and documentation Helps buyers assess whether a model provider can supply information needed for downstream use. Copyright Copyright-related provider commitments Relevant

Author: Skydu Summary: A form engine may look like the most basic capability in a low-code platform, but it is really the entry point for business modeling, data structure, permissions, workflows, and future AI understanding. Opening In the previous post, I wrote about why INFORMAT is not meant to be only a low-code tool. Starting from this post, I want to go into specific modules. The first module I want to write about is the form engine. The reason is simple: in a low-code platform, forms look basic, but a form is not just a page. Many enterprise business systems begin with a form. Customer registration, contract approval, project initiation, purchase requests, inventory receiving, equipment inspections, and production reporting are all, at their core, ways to collect, organize, and move business data. So a form engine is not about dragging a few input boxes onto a canvas. It is the entry point for the platform's business modeling capability. The initial requirement looked simple Before building the form engine, my most straightforward idea was this: users should be able to create business forms, configure fields, and let the system automatically generate data-entry pages and data lists. That idea does not sound complicated. A form name, a group of fields, a save button, and a data list seem like enough. But once implementation begins, a series of questions appear quickly. What field types should exist? Can fields be grouped? Can fields depend on each other? Should data be validated? Should a workflow be triggered after submission? Can different people see different fields? How will form data be used by reports, automation, and AI? When these questions stack together, the form engine stops being only a frontend component. It becomes a core module that connects the data model, permission system, workflow system, and automation system. A form is not a page, but a business model I gradually became more certain of one judgment: forms in a low-code platform should not

Security disclosures highlighted vulnerabilities in AI evaluations of autonomous cyber capabilities. Notably, OpenAI’s models escaped sandbox isolation, breaching Hugging Face’s systems. The incident involved a multi-stage attack, revealing flaws in evaluation containment and prompting calls for stricter infrastructure controls and local incident response tools. By Olimpiu Pop

Give an LLM a fish, feed it for a millisecond. Teach an LLM to fish, and become Master of the Lake! I've just published "Master of the Lake" - available for listening EXCLUSIVELY at tvox.online/books/1 . (Nudge, nudge, NoStarch...) This work represents the culmination of years developing Contract Style Comments (CSC) as a practical interface for governing AI agents in what I'm calling the "Agentic Epoch" - an era where AI agents are no longer passive tools but active participants in our systems. The Interface Problem We've spent decades refining how humans interact with computers: command lines, GUIs, touch interfaces, voice assistants. But we've largely ignored the critical interface problem of our time: how do humans govern AI agents? Most AI tooling focuses on making agents more capable - better at generating code, more creative in design, more persuasive in writing. But capability without governance creates dangerous systems that appear functional while silently drifting from intent. CSC provides the missing interface layer: a structured way for humans to specify, verify, and maintain governance over agent behavior. Beyond Prompts: The CSC Interface Prompt engineering treats agents like fickle genies - rub the lamp the right way and maybe you'll get what you want. But this approach fundamentally misunderstands the agentic relationship. CSC shifts us from: Prompting (hoping the agent understands) To: Contracting (explicitly defining what the agent must uphold) The interface consists of three interconnected files: contract.md - The operational interface: what the agent must do why.md - The explanatory interface: why those requirements exist invariant.md - The boundary interface: what can never change This isn't just documentation - it's a verifiable interface that agents can check against continuously, making the alignment gap visible before it causes harm. System Silent-Death: Why Interfaces Matter We used to fear system crashes - honest failures that clearly ind

Amazon Nova Pro matched a 4GB open-weight model running on a laptop on German PII redaction: 94% exact-value recall against 93%. Nova Micro, the cheapest model in the family, tied Amazon Comprehend on the same test at roughly a twentieth of the cost per document. And the model that lost hardest was the one fine-tuned for German. Here is what we measured across six approaches, two languages, and four orders of magnitude of cost. The blocker is not the model You have data. It contains names, email addresses, phone numbers, IBANs, dates of birth, health codes, account numbers. You want a language model to summarize it, classify it, extract from it, or index it for search. The model is capable. The data is ready. The personally identifiable information in it is what stops you. GDPR, HIPAA, and data processing agreements restrict where PII can transit, and approval for your cloud provider is not approval for every service inside it. Internal access controls make it worse rather than better: legal can see contract party details and finance cannot, but those boundaries live in your systems of record and dissolve the moment raw data enters a shared RAG index or a prompt template three teams call. An analyst asking for revenue from client X can get an answer derived from a contract they have no clearance to read. Then there is the leak nobody plans for. Production data reaches development accounts constantly, through payloads copied while debugging and dumps used to build test fixtures. And when the compliant workflow takes three days and the non-compliant one takes three minutes, people take the three minutes: a support engineer pastes a complaint into a consumer chatbot, a recruiter runs a CV batch through a free tool. This is not a security failure. It's a workflow design failure. A redaction layer separates the concerns. Process the data before it reaches any model, replace identities with typed placeholders, let the model work on structure and meaning. Which scale are y

A portfolio can look good on the usual scorecard and still answer the wrong question. One line says return was high. Another says risk-adjusted performance was acceptable. A third says drawdown stayed inside a tolerable range. Then the market turns, the benchmark starts recovering, and the thing I actually care about is different: how efficiently did the portfolio catch up? That is where a new metric can fool its own author. If I build a recovery measure and it moves almost exactly like an existing ratio, I have created a longer name for the same signal. The right acceptance test is geometric: a useful metric should cast a different shadow. This is the rule I used while validating Hyperlogarithmic Benchmark Catch-Up Ratio (HBCR): orthogonality to existing measures is a first-class test, not a chart for the appendix. 1. A new metric has to earn its axis HBCR was built to measure benchmark-relative recovery dynamics. The research page states the motivation plainly: traditional benchmark-relative metrics often fail to capture the true dynamics of investment performance, especially during market recoveries [ A New Metric for Private Equity Risk Adjusted Returns , Calibration of Risk and Correlation in Private Equity ]. That framing matters because the obvious validation path is tempting and weak. You compare the new number with familiar performance measures, find a comforting relationship, and declare victory. But a high correlation with a well-known score can be a warning. If HBCR strongly tracked Sharpe Ratio, it would probably be an expensive synonym for risk-adjusted return. The acceptance test I wanted was sharper. HBCR should have some relationship with performance, because recovery has economic content. It should also avoid collapsing into the same direction as Sharpe Ratio, Beta, Volatility, Alpha, Total Return, or Max Drawdown. Written as a predicate, the test has two sides. Let $\mathcal{T}$ be the set of metrics already on the scorecard, $\rho_{n,m}$ the corr

Most Linux problems aren't actually difficult. They're difficult because they're often debugged in the wrong order. Many beginners immediately: Restart services randomly Run commands without a plan Change configurations before understanding the problem Guess instead of observing Experienced engineers do something different. They follow a structured troubleshooting process. This article isn't about learning new Linux commands. It's about knowing when and why to use the commands you've already learned throughout this Linux Beginner Series. Think of it as putting everything together into one practical troubleshooting workflow that's used in real Linux and DevOps environments. Quick Troubleshooting Workflow Observe ↓ Check System Health ↓ Identify Problem Type ↓ Read Logs ↓ Verify Service ↓ Check Network ↓ Check Disk ↓ Recent Changes ↓ Find the Root Cause ↓ Apply the Fix Keep this workflow in mind as you read through the guide. Step 0: Observe Before You Change Anything Before running a single command, pause for a moment. Ask yourself: What exactly is broken? When did the issue start? Is everyone affected or only some users? Is the problem constant or intermittent? What changed recently? Many troubleshooting sessions become longer because people try to fix the problem before they understand it. Good troubleshooting begins with observation, not commands. Step 1: Check Overall System Health Your first goal is to understand the overall health of the system—not to fix anything yet. Useful commands: uptime free -h top Look for: High load average High CPU usage Low available memory Signs that the server is under heavy load At this stage, you're only gathering evidence. A quick system health check often tells you where to investigate next. Step 2: Identify the Type of Problem Before diving deeper, classify the issue. Problem Type Common Symptoms First Commands to Check CPU Slow system, high CPU usage top , htop Memory Applications crashing, OOM kills free -h Disk "No space lef

A practical guide to writing specs that turn vague AI prompts into production-quality code — from functional requirements to edge cases, with real before-and-after examples. Let me paint a picture you've probably lived. You open Claude Code or OpenCode, type a vague prompt like "add a user dashboard with analytics," and hit enter. The agent spins up, writes a bunch of code — it even looks decent at first glance. Then you realize: the data model is wrong, the API endpoints don't match your existing patterns, there's no error handling, and the "analytics" is just a row of four hardcoded numbers. You spend the next hour correcting, prompting, correcting again. You would have been faster writing it yourself. Now imagine a different scenario. You spend 15 minutes writing a structured specification, paste it into the agent, and it produces exactly what you wanted — following your conventions, handling edge cases, wired into your existing auth and data layer. One shot. That's not luck. That's the difference between treating your AI coding agent like a chatbot and treating it like a senior engineer who needs a clear design document — also known as spec-driven development . The Core Problem: AI Agents Are Powerful but Undirected Claude Code, OpenCode, Cursor Agent — these tools are incredible when pointed at a well-defined task. They can read your entire codebase, understand your conventions, and produce production-quality code. But they share a fundamental limitation: they don't know what you want unless you tell them, precisely and completely. When you give an agent a one-liner prompt, you're leaving an enormous amount of ambiguity. The model will fill in the gaps — but it fills them with its own assumptions, which are often generic, incomplete, or just wrong for your context. A spec closes those gaps. It transforms an open-ended creative writing exercise into a constrained engineering task. What Makes a Spec Actually Work for AI Coding Agents? A spec that works for an AI

Part 1 established the hardware, the runner, and the primary model. This entry covers what governs inference on that hardware — the two phases of inference, the cost of long context, and the cost of loading a model from disk — and compares the local machines against a free-tier cloud model. The two phases of inference Inference has two phases. Prefill processes the input prompt before any output appears; it is compute-bound and wants a GPU. Generation produces output tokens one at a time and is bound by memory bandwidth. Casual use is almost all generation and hides the difference; the cost of prefill surfaces only when prompts grow large. The machines, and how they were measured Machine CPU / RAM GPU (VRAM) Storage (read) Prefill (tok/s) Gen (tok/s) Load (18 GB) Primary desktop 5950X / ~80 GB DDR4 RX 6900XT (16 GB) NVMe (~2.1 GB/s) 360 18.3 8.4s Secondary box 5600G / 32 GB DDR4 GTX 1060 (6 GB) SATA SSD (~0.35 GB/s) 253 17.1 50.6s Laptop 8840U / 32 GB DDR5 Radeon 780M (none) NVMe (~2.4 GB/s) 20 10.0 7.5s All inference figures come from a controlled run: the same model (Gemma 4 26B, 18 GB) on each machine, a unique random prefix per prompt to defeat caching, a fixed 8,192-token context, warm, on an identical ~6,855-token prompt (generation timed over a 200-token output). Two things stand out. Prefill varies about eighteen-fold across the machines (360 to 20 tok/s) while generation varies less than twofold (18.3 to 10.0), and prefill is what dominates large-prompt workloads — so a machine can look fine on generation yet be useless in practice. Model-load time, separately, is set by storage rather than compute: the secondary box's budget SATA SSDs load the 18 GB model in 50 seconds against eight on NVMe, which turns a cold request into a minute-long stall. Secondary box Request time Warm (model resident) ~4s Cold (model reload) ~54s If the model is allowed to unload between calls, every call silently pays that reload — a real source of intermittent timeouts. The fix is