标签：#mac

Automatic speech recognition is very good until somebody mentions the name of a local school, a village, a politician, a festival, or a cricket ground. Then things get strange. In an earlier test with audio from Barbados, GPT Transcribe and GPT Audio 1.5 heard the event name “Rise Together” as “Rice Together”, while Qwen3.5-Omni Plus and Flash got it right. Those are different models from the Qwen3-Omni checkpoint used here, but the result motivated this experiment. Acoustically, the mistake is understandable. Culturally, it is wrong. A person who knows the local context has another signal available: they know that Rise Together is the plausible name. That led me to a question: can we give an audio-native model a stronger model of Barbados, using text that already contains the names, institutions, places, events and relationships it is likely to hear? So I took an archive of Barbados newspapers, turned it into 51.6 million tokens, and used it for domain-adaptive pretraining of the Thinker inside Qwen3-Omni. The result is promising, but not conclusive. The adapted model produced higher scores on our preliminary Barbados knowledge probe, particularly on people and institutions. It also got slightly worse on a small set of general-knowledge controls. And, most importantly, we have not yet shown that it transcribes audio more accurately. This is a very preliminary result. It came from our first training run, which we stopped at step 500 of a planned 801 steps. We were also still extracting the newspaper archive, so the 51.6 million training tokens represent the material available for that run rather than the full corpus we ultimately intend to use. This post is about what we have actually demonstrated, what broke along the way, and why I think the experiment is still worth pursuing. The Problem Is Not Just Acoustic A transcription model is doing more than converting sound into letters. When audio is clean and a word is common, the acoustic evidence can be enough. But re

Every failure I am about to describe produced a clean run. No exception, no stack trace, no red build. Each one produced a plausible number that I believed for longer than I should have. That is the category of bug I have come to fear most. A crash tells you it crashed. A silently broken dataset tells you nothing at all, and your metrics will politely agree with it. Here are three from the last year, all from my own work, all found late. 1. The dataset that was 92% one category I had a training set of 688 records for a multi-category vision-language task. Thirteen categories. Reasonable size for a fine-tune, already used in a completed training run whose results I had written up. While preparing a stratified split, I joined the records back against the source annotations and actually counted the categories. 630 of 688 were a single category: scene captions. Zero examples of traffic signals. Zero of planning. Zero of uncertainty. Several categories the evaluation explicitly measured had no representation in training at all. The previous fine-tune had shown gains on some of those very categories. I had interpreted this as the model learning the task. The real explanation was duller and more useful: the model had learned the answer format from caption supervision, and format alignment alone was enough to move a multiple-choice score. Nothing category-specific had been learned, because nothing category-specific had been shown. The root cause was upstream and boring. The conversion script I inherited only rewrote file paths and dropped records with missing frames. It faithfully preserved a caption-only selection made further up the chain. It had no opinion about balance because nobody had asked it to have one. What I changed: the composition of a training set is now an artifact I generate and inspect before any run, not a property I assume. A category histogram takes seconds. I had not looked, for months. 2. The 18-hour run that converged perfectly to nothing Large model

I benchmarked a vision-language model and scored it at 0.31. The real number was 0.70. Same model, same weights, same hardware, same 100 questions. The only thing that changed was how I read its output. I had already written up the 0.31 as a capability finding and concluded the model was unsuitable. That conclusion was wrong, and the failure was entirely in my harness. Here is the mistake, because I doubt I am the only one making it. The setup I was evaluating a batch of open-weight and frontier models on a multiple-choice benchmark: multi-view driving scenes, four options per question, one correct answer. Standard stuff. The prompt asked for reasoning followed by a final line, Answer: X . My scoring code did the obvious thing: m = re . search ( r " Answer:\s*([A-D]) " , output ) pred = m . group ( 1 ) if m else None # None scores as wrong That last comment is the bug. What actually happened The model I was testing is a "thinking" model. It emits a long internal reasoning trace before it commits to an answer. I had a generation budget of 1024 tokens. On easy questions it reasoned briefly, emitted Answer: B , and scored fine. On hard questions it reasoned at length, hit the token cap mid-thought, and never emitted the answer line at all. So the harness scored every one of those as wrong. 64 of 100 questions returned no parseable answer. Zero of those were image-loading errors or crashes. They were all truncation. And the truncation was not random: Uncertainty 0/8 answered Counterfactual 0/3 answered Safety-critical Planning 1/11 answered Safety-critical Prediction 3/12 answered Look at that distribution. The questions the model failed to answer were precisely the questions that required the most reasoning. My harness was systematically discarding the model's performance on exactly the hard subset I was trying to measure, and reporting the result as a capability ceiling. Of the 36 it did answer, it got 86% right. The model was fine. My measurement was garbage. The fix

OpenAI quietly rolled out improvements to GPT-5.6 Sol in ChatGPT this week, and the AI community took notice. The update, which hit the front page of Hacker News with over 70 points, brings measurable quality improvements and — crucially — expands access to free users. What Changed in GPT-5.6 Sol? The update focuses on three areas: 1. Improved Reasoning on Complex Tasks GPT-5.6 Sol shows improved performance on multi-step reasoning tasks. This includes better handling of: Mathematical proofs and calculations Code debugging across multiple files Logical deduction chains Multi-constraint optimization problems The improvement appears to come from refined training data curation and reinforcement learning from human feedback (RLHF) targeting reasoning-heavy tasks. 2. Better Instruction Following The model now follows complex, multi-part instructions more reliably. Where GPT-5.6 Sol previously might miss one constraint in a list of five, the updated version handles compound instructions more consistently. For developers building prompt-based applications, this means: Fewer retry loops Better structured output generation More reliable tool calling 3. Expanded Free User Access Perhaps the most significant change for the broader AI community: OpenAI expanded free user access to GPT-5.6 Sol. Previously available only to Plus subscribers, the model is now accessible to a wider audience. This has implications: For developers : Larger potential user base for GPT-5.6-powered apps For competitors : Pressure on pricing — if the best models are free, paid tiers need clear differentiation For open source : The gap between free proprietary models and open-source alternatives narrows the value proposition of self-hosting How Does It Compare? The Artificial Analysis Agentic Index — an independent benchmark — currently ranks GPT-5.6 Sol among the top models, though Qwen3.8 Max has recently taken the #1 spot on agentic tasks. The competitive landscape as of August 2026: Model Intelligence

The AI leaderboard just had a seismic shift. Qwen3.8 Max, Alibaba's latest open-weight model, has been ranked as the best overall model by the Artificial Analysis Agentic Index — beating out GPT-5.6 Sol from OpenAI, Claude Opus 4.5 from Anthropic, and Gemini Ultra 2 from Google. This isn't just a benchmark win. It's the first time an open-source model has topped a comprehensive agentic intelligence index that measures real-world task performance, not just test scores. What Is the Agentic Index? The Artificial Analysis Agentic Index is an independent benchmark that evaluates AI models on their ability to complete agentic tasks — multi-step reasoning, tool use, code generation, and real-world problem solving. Unlike traditional benchmarks (MMLU, HumanEval) that test static knowledge, the agentic index measures whether a model can actually do things . The index evaluates models across multiple dimensions: Intelligence Index : Composite score across reasoning, coding, math, and instruction following Speed : Output tokens per second under production load Cost : Weighted average cost per intelligence task Endpoint Accuracy : Whether provider endpoints match reference model quality Qwen3.8 Max: The Specs Qwen3.8 Max represents Alibaba's most capable model to date: Parameters : 240B (MoE architecture, ~35B active during inference) Context : 256K tokens native, 1M extended Training : Trained through November 2025 data cutoff Licensing : Open weights for research and commercial use (with restrictions for users in restricted jurisdictions) What makes Qwen3.8 Max notable isn't just raw intelligence — it's the combination of high performance with competitive pricing and speed. The model scores near the top on intelligence while maintaining cost per task well below premium alternatives. Why This Matters for Developers 1. Open-Source is Catching Up — and Pulling Ahead For two years, the gap between open-source models (Llama, Qwen, Mistral) and proprietary frontier models (GPT, Cla

Whether generating CELEBV-HQ videos or turbulent plasma fields (digital twins), autoregressive models (such as latent diffusion or flow models) accumulate error over long rollouts, yet at deployment there is no ground truth to measure against. I train a single conditional latent diffusion model that steps a dynamical system forward or backward in time via a direction flag, and show that this bidirectionality supplies a measurement-free test-time error signal: rolling forward steps and then backward steps must return the model to its start, so the round-trip discrepancy is a self-supervised proxy for the unobservable rollout error: no ensembles, no held-out data, no governing equations, for one extra rollout. Furthermore, training both directions in one network is shown to beat two specialist models in both directions. Paper: https://arxiv.org/abs/2608.00675 Code (data generation, training, analysis): https://github.com/alexscheinker/round-trip-consistency Project page: https://alexscheinker.github.io/roundtrip.html submitted by /u/Clean-Hovercraft5825 [link] [留言]

Originally published in Spanish on El Rack. Browser translation handles the rest of the site fine if you're into homelab/self-hosting content. Moonshot AI released Kimi K3 on July 17, 2026, and made the weights publicly downloadable on July 27. At 2.8 trillion parameters, it's the largest open-weight model ever published — and according to multiple benchmarks, it rivals Claude Opus and GPT on coding, reasoning, and general knowledge work, at a fraction of the training cost. The New York Times ran an in-depth piece on it a few days after release, which tells you this isn't just another model drop. What "open weights" actually gets you here Publicly downloadable weights mean any company or researcher can run this locally and modify it without depending on a third-party API. If you already run Ollama or LM Studio in your homelab, that's the tempting part: a frontier-level model, no monthly quota, running on your own hardware. The practical reality is different. "2.8 trillion parameters isn't a number that runs on homelab hardware — it needs an enterprise-grade GPU cluster. The weight release is real, but "downloadable" and "runnable" are very different things at this scale." The bigger debate this reopened What makes Kimi K3 interesting isn't just the benchmark numbers — it's what it represents in the ongoing dispute over AI's geopolitics. The same fracture that opened up around DeepSeek-R1 in January 2025 is back: some argue US labs need to close up more in response to Chinese competition, others see openness as the only real way to stay relevant against an ecosystem that ships open weights at a pace closed labs can't match on transparency. There's also a real technical concern underneath: the possibility that outside actors use massive querying of closed American models to distill their outputs and train competing open models. Where this actually matters for a homelab Even though K3 itself is unrunnable on consumer hardware, its release pushes down what smaller, actu

The problem I was running a multi-agent pipeline and one of my agents silently failed. The only alert I got said "daily loss limit reached" — completely misleading. The real cause was a missing file the agent never reported. I had zero visibility into what any agent had actually done. What I built AgentLens — a Python SDK for AI agent governance. Three modules: Audit trail — every LLM call and tool use logged to SQLite automatically Authorization — policy-based gates so agents can only call what you've approved Anomaly detection — baseline + threshold config, alerts when behavior drifts One-line integration Drop-in for Anthropic: python from agentlens.integrations.anthropic import TracedAnthropic client = TracedAnthropic(agent_id="my-agent") response = client.messages.create(...) # auto-traced

Builder Journal · Mars Environmental Dynamics Analyzer (MEDA) Virtual Sensor Recovery Ten times in a row I predicted what my next submission would score before I uploaded it. The worst miss was 0.0025 on a number around nineteen. I took that as confirmation that the physics underneath was correct. It was confirmation that I can do arithmetic. Two days before this competition closed I pointed a review at my own endgame, expecting notes about the code. It came back with three errors and none of them were in the code. All three were in my reasoning, and all three had the same shape: I had run something that felt like a measurement and was not one. This is the fourth entry in this series and the one I would keep if I had to burn the other three. The models are competition-specific. This part is not. The competition in one breath Perseverance carries an environmental station called MEDA. Some of its surface pressure readings are missing, and the competition is to reconstruct them. Scored on mean squared error. The wrinkle is the split. Training covers sols 1 through 100, when pressure is climbing toward its seasonal peak. Test covers sols 201 through 300, when it is falling hard toward the aphelion minimum. Sols 101 through 200 do not exist in either file. Every prediction is outside the range the model was fit on. The first entry covers the first submission, which contained no machine learning at all and took the top of the board at 61.04. Six weeks and seven versions later the public score was 18.99. Almost everything in between was selected by one signal. Not cross-validation. Cross-validation here can only hold out sols from the rising limb, so it is structurally blind to the regime I am scored on. The leaderboard was the only thing that could see the falling limb, so the leaderboard picked every scalar that mattered: the residual shrink, the blend weight, a constant seasonal offset, a diurnal scaling. Hold onto that. It becomes the joke about four hundred words from

TL;DR: LLMs charge per token, but control how tokens are generated. So the real skill isn’t prompting better—it’s constraining output to reduce entropy and cost. I. The Political Economy of Metered Latent Space In traditional public utility infrastructure, metered consumption follows a clear material logic: the unit of billing corresponds directly to a tangible, user-controlled commodity—gallons of water, kilowatt-hours of electricity, or therms of natural gas. While the provider owns the infrastructure and the meter, the user dictates the exact rate and volume of consumption required to accomplish a physical task. The modern cloud-based Artificial Intelligence (AI) ecosystem introduces a structural asymmetry into this model. Under prevailing API pricing and enterprise subscription frameworks, Western hyperscalers meter access to Large Language Models (LLMs) per token—covering both context input ingestion and payload output generation. Crucially, however, the platform retains operational control over how those tokens are selected, expanded, and emitted. This arrangement produces an alignment of incentives consistent with structural surplus capture, regardless of specific vendor intent. When platform revenue scales linearly with output generation volume, the system's economic environment selects for high-entropy conversational output—politeness markers, administrative hedging, corporate disclaimers, and redundant summaries. Conversely, zero-entropy symbolic execution yields minimal billable payload. The user thus incurs an emergent "conversational tax," where surplus tokens serve the economic logic of the host rather than the computational objective of the operator. II. Output Densities and Execution Constraints To understand how token economics intersect with model behavior, output payloads must be evaluated through information density and interface constraints rather than naive string tokenization. The Field-Array Operator Algebra (FAOA)—a proposed abstraction laye

It feels like LLMs are partially leveling the playing field in ML research. A solo researcher or a two-person team can now get help with coding, literature review, writing things stronger labs usually get from experienced colleagues and large networks. Obviously, LLMs don’t replace mentorship, or good research taste. But they may help researchers with weak networks or small groups turn good ideas into publishable work. Do you think this is actually making ML research more accessible, or are the strongest labs benefiting even more? submitted by /u/Hope999991 [link] [留言]

Hello, I am currently studying deep learning and have completed several AI/ML projects. I am specifically looking to join an ongoing AI/ML project where I can actively contribute and further develop my skills. I am committed, eager to learn, and open to collaboration. If you have a project and are open to contributors, please feel free to reach out. submitted by /u/Quiet-Cod-9650 [link] [留言]

Over the past month, I've been building LiveTranscriber, an open-source iOS app for running modern speech and language models entirely on-device. The goal was to see whether recent open-source models could be turned into a practical mobile product—not just technical demos. Currently supported local models include: - Whisper for offline transcription - Qwen3-ASR for multilingual speech recognition - NVIDIA Nemotron Streaming for low-latency live transcription - MOSS Multi-Speaker for speaker-aware transcription - Qwen3 for local summaries, key points, titles, and transcript analysis Features include: - 100% offline speech recognition - Offline multi-speaker transcription - On-device summaries and key-point extraction - Real-time translation - Apple Watch recording with automatic sync - Downloadable and switchable local models - Searchable transcript history The main engineering challenge was not simply running the models, but making them usable on iPhone: memory management, streaming latency, model loading, context handling, battery usage, and switching between different inference backends. The project is fully open source: GitHub: https://github.com/iamwilliamli/LiveTranscriber App Store: https://apps.apple.com/us/app/live-transcriber-recorder/id6785515364 I'd appreciate feedback from anyone working on ASR, local LLMs, on-device AI, Core ML, or mobile inference. submitted by /u/marshmallow_ki [link] [留言]

Comparisons between SAFi and techniques such as reinforcement learning from human feedback, or RLHF, are useful only up to a point. Constitutional AI is a closer conceptual comparison because it introduces explicit principles into the process of generating and evaluating responses. Even so, these approaches address a different layer of the problem. RLHF and Constitutional AI primarily shape how a model behaves. SAFi governs how an AI agent operates. That distinction matters because an AI agent is not only a language model producing text. It may interpret requests, reason about possible responses, decide whether to act, call tools, access information, modify data, and produce an answer that must be accountable to the organization deploying it. The conventional architecture: the model at the center Much of today’s AI governance consists of filters, classifiers, guardrails, monitors, and policy checks placed around the model. The general pattern looks like this: A request reaches the model. The model generates a response or proposes an action. External controls inspect the input, output, or tool request. The system allows, blocks, modifies, or records the result. This architecture can be valuable. External controls can detect prohibited content, restrict certain actions, and provide monitoring or enforcement. They are often necessary parts of a responsible deployment. But the architecture still places the model at the center of the process. Governance is positioned around the model as an additional control mechanism. In many systems, the evidence needed for explanation and audit is also collected after the model has produced its output or proposed its action. That creates a basic separation between execution and governance: The model produces the draft. The governance system evaluates the draft. The monitoring system records what happened. The controls may be effective, but governance remains an external activity surrounding the primary intelligence. SAFi’s architectur

Jeff Dean and other high-profile Google executives have founded Discovery Loop, a startup that will seek AI-powered breakthroughs in everything from drug discovery to chip design.

LaTeX is a document preparation system for high-quality typesetting, perfect for academic papers and technical docs. Many people turn to Overleaf as their go-to online editor for LaTeX, but it comes with its own frustrations. If you are tired of Overleaf being costly and always hitting the compile timed out error, this guide is for you! The full MacTeX install weighs in at a massive ~6.4GB, most of which you'll never actually use. Setting up a minimalist LaTeX environment on macOS using BasicTeX and VSCode is a much better alternative that makes your setup ~8 times smaller. It saves storage and makes it much easier to collaborate with your teammates using GitHub as a combo. Install LaTeX via Homebrew We'll use Homebrew to keep things manageable. If you don't have it, grab it at brew.sh . 1. Install LaTeX BasicTeX is the "lean" version of MacTeX. It's only ~140MB initially. brew install --cask basictex 2. Refresh your path and verify Make the TeX binaries available in your current terminal session: eval " $( /usr/libexec/path_helper ) " The default LaTeX compiler pdflatex should be available now. Verify it's working: which pdflatex pdflatex --version 3. Update tlmgr and packages tlmgr is the TeX Live Manager. To update tlmgr and all packages, run the following commands: sudo tlmgr update --self sudo tlmgr update --all 4. Install latexmk (build manager) latexmk is the "build manager" that handles multiple runs of the compiler (necessary for bibliographies and tables of contents). sudo tlmgr install latexmk Verify latexmk version: which latexmk latexmk --version 5. Install essential package collections BasicTeX is too bare-bones for real projects. Since we went minimalist, we need to grab only the packages we actually use. These three collections will cover 90% of your needs while keeping storage down. sudo tlmgr install collection-latexrecommended sudo tlmgr install collection-fontsrecommended sudo tlmgr install collection-latexextra Note: If a build fails due to a mi

MacPaw is building a local version of its AI assistant Eney using Liquid AI's models.

Laurence Tratt discusses yk, an open-source meta-tracing JIT compiler framework. He shares how to automatically speed up C-based language interpreters like Lua and MicroPython with minimal, non-invasive code changes. He explains the inner workings of tracing loops, optimizing compiled traces using developer hints, and managing complex deoptimization back to the interpreter. By Laurence Tratt

Hi everyone, I'm an independent researcher sharing Monodratic, a sparse causal-attention architecture with learned product-hash routing. The idea is that after RoPE, source blocks are assigned to bounded causal posting lists, while each query probes product addresses, reranks the returned candidates, selects a fixed number of remote source blocks, adds guaranteed local blocks, and then runs exact causal softmax over just those tokens. I implemented it as a stateless [batch, sequence, width] -> attention-delta mixer, so normalization, residual updates, feed-forward layers, and inference scheduling are left to the host model. What I found is that -learned routing with 2 selected remote blocks out of 5 eligible: 763/768 correct associative-recall answers across three seeds (99.35% mean, 98.05% minimum). -an equally wide untrained router: 425/768. Local-only attention: 151/768. -forcing the labelled target block while keeping the same maximum R2 attention budget recovered all five remaining errors, reaching 768/768. -sparse selected-set attention agreed with an independent dense selected-mask oracle to a maximum absolute error of 1.43e-6. -the packed CPU routing implementation showed a fitted timing exponent of 0.993 from 4,096 to 32,768 tokens under the fixed, balanced configuration. -all reported learned-route and scaling runs recorded zero posting overflow. The limitations are that the experiments are synthetic, the implementation is portable PyTorch rather than a fused kernel, and the report does not claim natural-language quality, asymptotic linear construction, or deployment speed. Paper: https://github.com/Misul-Computing/Monodratic/blob/main/output/pdf/monodratic_proof.pdf Code and reproduction: https://github.com/Misul-Computing/Monodratic I would particularly appreciate technical feedback on the routing construction, the controls, and what the strongest next evaluation should be. submitted by /u/dttdrv [link] [留言]

Beyond Size: The Three Pillars of Test-Time Scaling in Large Language Models The narrative of artificial intelligence for the last decade has been dominated by a single, powerful trend: scaling. From the early days of AlexNet to the massive clusters powering GPT-4, the formula seemed simple—more data and more parameters lead to better performance. This paradigm, famously codified as the "Scaling Laws," suggested that we could predict model improvements simply by looking at the amount of compute poured into the pre-training phase. However, as the industry pushes against the boundaries of available high-quality data and the physical limits of hardware, a new dimension of scaling is emerging. It isn't about how large the model is, but how long it "thinks" before it speaks. This shift toward "test-time scaling" marks a transition from static intelligence to dynamic reasoning. Instead of relying solely on the patterns learned during training, models are now being equipped with the computational budget to explore, verify, and refine their answers at the point of inference. While the concept was popularized by the release of models like OpenAI’s o1 series , the underlying mechanics remained somewhat opaque. A recent comprehensive study by Hariri et al. (2026), titled " Test-Time Scaling in Reasoning LLMs: Inference Regimes, Evaluation, and Reproducibility ", provides a much-needed formal framework for understanding this new frontier. The Three Regimes of Inference Compute The core contribution of the Hariri et al. paper is the formalization of test-time scaling into three distinct structural regimes. Rather than treating all "extra compute" as a single scalar budget, the authors map how compute is allocated across the implicit prefix tree of an autoregressive model. 1. Single-Trajectory Sequential Scaling This is the most familiar regime, often associated with Chain-of-Thought (CoT) prompting. In this mode, the model generates a single sequence of tokens. Compute is scaled