标签：#Mac

I had a paper accepted to a conference. This paper was originally published as a preprint. Subsequent works citing our preprint focused on the same topic and reused/extended our methodology. I am now preparing the camera-ready version of that preprint and I'm wondering how I should deal with this for the Related work section. It seems odd to me to cite my own preprint for the camera-ready version of the paper (and I am not even sure if this is allowed), but at the same time, I don't want to undermine the novelty of my original work (nor undermine the efforts of subsequent works). Has anyone dealt with such a situation before? What's the best way of solving this? submitted by /u/Vulcapulae [link] [留言]

Never attended a conference before, so apologies if these are dumb questions. I’m an author of an accepted paper at COLM 2026. One of my coauthors registered during the author-only registration period, so I joined the waitlist on August 10. I later received an email saying: “Your access to reserve tickets remains active until Aug 24 7:06 p.m. EDT.” I thought I had until August 24 to register, so I didn’t register immediately. When I checked again today (8/23), registration was sold out. I also can’t seem to rejoin the waitlist. Unfortunately, I also missed the financial assistance deadline because at the time I wasn’t even sure whether I would be able to attend. I really really want to attend the conference. Does anyone know what I can do at this point? Is there a chance that more registration spots will be released later? And is there any possibility of getting financial assistance after the deadline? Thanks a lot for any advice. submitted by /u/mziycfh [link] [留言]

My dumbass just realized all NeurIPS workshops are non-archival. In terms of grad school applications, would there be a difference in how much they value ur paper if u get it in a proceeding submitted by /u/Wonderful_Entry9371 [link] [留言]

been building ShardFlow for the past few months, a distributed LLM inference framework that splits any HuggingFace transformer across N GPU machines and uses neural speculative decoding to deal with WAN latency. the setup for the benchmark: two T4 nodes in separate GCP regions (Iowa + Oregon) talking through an AWS EC2 TCP relay in Ohio. ~86ms RTT on public internet. the key insight with speculative decoding here is that WAN latency stops being a per-token cost and becomes a per-round cost. with K=8 drafting you're committing 4.07 tokens per round trip instead of 1. at 86ms RTT that's a big deal. numbers on Qwen2.5-7B: non-speculative baseline: 4.92 TPS neural drafter (eager): 14.3 TPS peak + CUDA Graphs on drafter: 28.10 TPS peak / 20.31 TPS avg also ran Qwen2.5-14B with NF4 4-bit quant, same two nodes: 14.43 TPS avg. the v2.1 fix that surprised me most: draft generation was launching ~1500 CUDA kernels per round from a Python loop. each kernel 2-5us, Python launch overhead 8-10us. GPU sitting idle 65% of the time. capturing the full 0.5B forward pass as a CUDA Graph and replaying with one driver call dropped draft latency from 112ms to 25ms. other things in the stack: zero-copy Rust TCP relay, StaticCache + in-place KV rewind for graph compatibility, meta-device model slicing to avoid loading 15GB into CPU RAM. repo: https://github.com/rautaditya2606/Shardflow happy to answer questions on the speculative decoding implementation or the CUDA graphs stuff specifically. submitted by /u/katua_bkl [link] [留言]

The last post was about making a number trustworthy. Leakage geometry, purge widths, de-overlap, a baseline that could not cheat. It ended with a minute-scale ceiling that held at 52% across seven configurations and a model family swap. This one is about what happens after you trust the number. Because a probability you are going to bet on is a different object from a probability you are going to report. The probabilities are not decorative The path-passage classifier is a three-class LightGBM. It returns p_up , p_down , p_none . Those go straight into the expected-value score that decides whether to take a trade and how big: long_score = p_up * ( B - C ) + p_down * ( - B - C ) + p_none * ( - C ) short_score = p_up * ( - B - C ) + p_down * ( B - C ) + p_none * ( - C ) B is the barrier, C the cost. Read the arithmetic. Every term is linear in a probability. Scale p_up by 1.2 and you scale the long score by very nearly 1.2. So miscalibration does not stay in the model. It becomes a bet-sizing error, in proportion, in the bins where the gate actually fires. A classifier that is right 70% of the time while claiming 90% is not 20 points wrong. It is sizing every position in that bin as though the edge were far larger than it is. Boosted trees are known for uncalibrated softmax output. I had been consuming it as if it were a probability. The audit Seven live assets. For each one, fit an Inductive Venn-Abers wrapper on the time-ordered older 80% of that model's training data, 6,988 rows, and evaluate against a 500-row uniform-random sample of the newer 20%, seed 42. The LightGBM models are reloaded from disk and left alone. Only the wrapper is fit. Measure Expected Calibration Error and log-loss, before and after. Asset ECE before → after ECE Δ Log-loss Δ BTC 0.1272 → 0.0621 -51.2% -5.5% ETH 0.1795 → 0.0298 -83.4% -11.5% SOL 0.1680 → 0.0386 -77.0% -10.6% XRP 0.2219 → 0.0645 -70.9% -17.7% ADA 0.1419 → 0.0369 -74.0% -8.0% LINK 0.1260 → 0.0737 -41.5% -1.2% LTC 0.1508 → 0.0603

Hi! I'm one of the chairs of the EACL 2027 Industry Track , so flagging the deadline here — it's about three weeks out and this community has a lot of people doing exactly the kind of work the track exists for. The EACL 2027 Industry Track provides the opportunity to highlight key insights and new research challenges that arise from the development and deployment of real-world applications using language technologies . We encourage submissions from industry, non-profit, government, and public-sector organisations, with the understanding that the end-users of these systems extend beyond the NLP community. See the Full CFP for the details https://2027.eacl.org/calls/industry/ ** Deadline: ** 11 September 2026, 23:59 AoE ** Length: ** 6 pages max; references, limitations, ethics, and appendices don't count. A dedicated "Limitations" section is mandatory — papers without one are desk rejected. ** Review: ** double-blind. No anonymity period, so arXiv preprints are fine. ** Proprietary data: ** no requirement to release it ** Notification: ** 18 December 2026. Conference is 9–14 March 2027. ** Submit: ** https://openreview.net/group?id=eacl.org/EACL/2027/Industry_Track We're also looking for reviewers — if you've got deployment experience and want to help, the volunteer form is here: https://forms.gle/TT6N2gtuoV5P3oYi6 Email: [ eacl2027-industry-track@googlegroups.com ](mailto: eacl2027-industry-track@googlegroups.com ) submitted by /u/kochkinael [link] [留言]

I recently implemented a minimal, educational version of SynthID-Text-style watermarking for language models. I saw anthropic post about how they'll start adding watermarks to their model responses and it made me very curious as to how they'll do it and what do they even mean by watermark here. Like will we start getting random ads or something in the middle of model responses or what. Then decided to read their article and found out that watermark is not a visible message at all. It is a subtle statistical pattern introduced while the model chooses its tokens. My implementation is not an exact reproduction of the original SynthID-Text system. I simplified or implemented a few components differently to keep the project understandable, but the main idea is there I think. Github: https://github.com/Saad1926Q/llm-watermark If you find it interesting then you may star the repo !! submitted by /u/Saad_ahmed04 [link] [留言]

Originally published on tamiz.pro . Introduction We are witnessing a fundamental shift in software architecture: the transition from passive APIs to active agents. While the industry has been obsessed with the race for Artificial General Intelligence (AGI) through massive cloud models, a parallel, often under-discussed revolution is happening locally. This is the emergence of the Agentic Operating System —a local-first stack where autonomous agents don't just chat; they operate files, manage repositories, and execute workflows using private, locally-hosted LLMs. This is not merely about privacy, although privacy is a critical driver. It is about latency, determinism, and the "Planning Problem"—the architectural gap between reasoning (what to do) and execution (doing it). Frameworks like Eliza have demonstrated that lightweight characters can maintain persistent state and tool usage. Meanwhile, projects like Hister are pushing the boundaries of agentic file-system manipulation. In this deep dive, we will dissect the architecture of a private agentic OS, analyze the mechanics of local orchestration, and address the hard engineering challenges of tool use and planning. 1. The Architecture of a Local Agentic OS A "private agentic OS" implies a software layer that sits between the user and the machine's resources (file system, network, CLI), mediated by an LLM running entirely on-device or within a private VPC. Unlike a traditional shell, which requires explicit human input for every command, an agentic OS maintains an internal state and can execute multi-step plans autonomously. 1.1 The Core Components To build or understand such a system, we must deconstruct it into five distinct layers: The LLM Layer (The Brain): This is the inference engine. In a private OS context, this is almost exclusively a local model (e.g., Llama 3, Mistral, Qwen) running via inference servers like llama.cpp , vLLM , or Ollama . The Memory Layer (The State): Agents need context beyond the immed

I was staring at a broken Next.js and Express backend integration late at night, convinced my AI agent had lost its mind. It was supposed to be a straightforward n8n automation pipeline. Yet, every time it ran, it hallucinated non-existent packages and dumped its context halfway through. My System 1 intuitive reaction flared up immediately: The LLM just isn't smart enough. I sat there, exhausted, ready to rewrite the prompt for the twentieth time. Engaging System 2 Taking a step back, I forced myself to engage my analytical System 2 brain. I wasn't dealing with a lack of model intelligence; I was dealing with a lack of infrastructure. I was running a massive, powerful AI model with zero guardrails. No persistent memory. No verification. Just dumping a giant Mongoose schema into a prompt and hoping for the best. I was essentially dropping a Formula 1 engine onto a wooden skateboard and wondering why it crashed at the first turn. What is Harness Engineering? I stopped obsessing over prompt engineering and started focusing on Harness Engineering. The model is just the engine; the harness provides the chassis, the steering, and the brakes. Here is how I completely restructured my agentic workflow: Context Management: Instead of flooding the context window with raw codebase dumps, I implemented targeted retrieval. The agent now only sees the specific files required for the immediate task. Standardized Tools: I integrated Model Context Protocol (MCP) servers, giving the model bounded, secure ways to execute actions rather than just generating text. Durable State: If a long-running workflow pauses or fails, the system now checkpoints its progress. It resumes exactly where it left off instead of starting from scratch. Strict Verification: "Looks good to me" is no longer an acceptable output. The agent is forced to run tests and verify the CLI output before concluding a task. Learn to Break the System The results were immediate. The hallucinations stopped, and the agent shif

Hey everyone! I wanted to share something I’ve been working on. I was inspired by projects from DeepMind and OpenAI, but noticed that most games are prohibitively difficult to integrate with an agent harness. So I built DelveRL from the ground up as a human-playable game with a structured API, deterministic simulation, procedural levels, partial observability, and enough strategic headroom for agents to compete and improve. It’s an endless turn-based roguelike where agents must explore, manage risk and resources, fight enemies, and escape each floor. Everything runs locally, including batched renderer-free environments and a recurrent PPO trainer. The included baseline reaches a median floor of 18, with extended runs reaching floor 33. The game, training code, checkpoint, bridge documentation, and raw benchmarks are all open source. I’d love to see what approaches people try - and how quickly the baseline gets crushed submitted by /u/SnyderConsulting [link] [留言]

The preprint can be accessed via the following link: https://arxiv.org/abs/2608.12408 (q-bio.NC / cs.LG). And for the code: https://github.com/nilsleut/evaluation-resolution-rsa The following assertion is frequently made in model-brain comparisons: untrained convolutional neural networks (CNNs) have the capacity to match or surpass backpropagation-trained CNNs at the early visual cortex (V1) in representational similarity analysis (RSA). The present study demonstrates that this phenomenon is predominantly an artefact of evaluation resolution. The configuration comprised a small CNN trained at 32px (CIFAR-10 subset), five learning rules (random init, backprop, feedback alignment, predictive coding, STDP), and was evaluated on THINGS-fMRI stimuli at six resolutions from 32px to 224px. The weights and normalisation were held fixed. The primary outcome of this study is the observed gap between the untrained and backpropagation-trained (BP) V1 alignment, which widens monotonically across the range of evaluation resolutions examined. Specifically, the gap grows from −0.001±0.007 at 32 pixels to +0.044±0.006 at 224 pixels, a pattern that holds consistently across the entire resolution sweep (n=5 seeds). The result holds across five rule conditions, human fMRI, directionally single-seed macaque ephys, the full training trajectory, and two off-the-shelf 224px-trained models (ResNet-50, Swin-Tiny). Therefore, an artifact resulting from a mismatch between training and evaluation resolution is not a contributing factor, since these models also peak at low resolution. Following the implementation of bit-identical-weight interventions wherever possible, the following were ruled out: train/eval resolution matching, Gabor/pixel low-level structure, the untrained baseline's uncalibrated batch-norm, and convergence of pooled features towards global brightness (though a single scalar luminance value did reach ρ=0.075 against V1, essentially matching the untrained network's own 0.076 —

I have got two papers which got desk rejected by PC saying they are previously got reviewed in arr. But those paper never got submitted ever. Any idea what can be done? submitted by /u/malakulmout347 [link] [留言]

I am trying understand how tree-based regression model handle the dependencies of the target variables on the interaction of explanatory variables. However my experiment revealed that my understanding about the fitting process of a lgbm is not correct. And I don’t know why. My experiment is quite simple: a target (for sake of simplicity only in [0, 1]) and two explanatory variables with two values such that the mean of the target is the same for each of the values of the explanatory variables. Then there is a third variable that models the interaction of the explanatory variables by a simple count. So in code: >>> import polars as pl df = pl.Dataframe( { „y“: [0, 0, 1, 1, 0, 0, 1, 1], # mean across „A“ values the same; mean across „B“ values the same „A“: [1, 1, 1, 1, 0, 0, 0, 0], „B“: [1, 1, 0, 0, 1, 1, 0, 0], „AB“ [1, 1, 2, 2, 3, 3, 4, 4] # just some IDs for the interaction } ) <<< I then fitted a lgbm just with „A“ and „B“ and got the expected constant 0.5 forecast >>> from lightgbm import LGBMRegressor lgbm = LGBMRegressor(min_child_samples=1) lgbm.fit(df[[„A“, „B“]].to_numpy(), df[„y“].to_numpy()) lgbm.predict(df[[„A“, „B“]].to_numpy()).round(0) array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]) <<< Then I did the same but with „AB“ and expected a perfect fit. But I was disappointed, it fitted to constant zero >>> lgbm = LGBMRegressor(min_child_samples=1) lgbm.fit(df[[„AB“]].to_numpy(), df[„y“].to_numpy()) lgbm.predict(df[[„AB“]].to_numpy()).round(0) array([0, 0, 0, 0, 0, 0, 0, 0,]) <<< I tried to code „AB“ as category. But still no perfect fit: >>> lgbm = LGBMRegressor(min_child_samples=1) lgbm.fit(df[[„AB“]].to_numpy(), df[„y“].to_numpy()) lgbm.predict(df[[„AB“]].to_numpy()).round(0) array([0, 0, 1, 1, 0, 0, 0, 0,]) <<< Super confusing! I then turned to catboost and found even without „AB“ it fit the data perfectly: >>> from catboost import CatBoostRegressor cbm = LGBMRegressor(min_data_in_leaf=1) cbm.fit(df[[„A“, „B“]].to_numpy(), df[„y“].to_numpy()) cbm.predic

Here's a dirty secret of search: "the closest match" and "the most useful result" are not the same thing. Return the mathematically nearest document and you'll often hand someone something technically related and practically useless. Relevance is a harder problem than similarity — and it's where good search is won or lost. Getting that right was the core challenge in the GovernAI Research Atlas , a semantic discovery platform I built to unify research across papers, repositories, and policy. Similarity is not relevance Semantic search gives you a superpower: embed everything into vectors and find items close in meaning , not just wording. But raw nearest-neighbor retrieval has a blind spot. The vector-closest result might be a tangential paper that happens to share vocabulary, while the genuinely useful one sits slightly further out. Distance in embedding space is a proxy for relevance — a good one, but not the whole story. If you stop at "closest vector," your search is clever and still frustrating. Ranking on top of retrieval The Atlas runs ChromaDB vector search with Sentence-Transformer embeddings across sources like OpenAlex and GitHub — that's the retrieval layer, the "what's semantically near this query." On top of it sits a custom relevance score that decides what actually surfaces first. That two-stage shape is the pattern behind every search system worth using: Retrieve broadly by meaning. Vectors pull in the semantically-relevant candidate set, fast, across a large and varied corpus. Rank deliberately. A custom scoring layer reorders those candidates by what's actually useful — because the job isn't to return related results, it's to return the right one first. Unify the sources. Papers, code, and governance material ranked into a single relevance-ordered experience, so discovery crosses formats instead of siloing them. Why this is the interesting part Retrieval gets the attention; ranking gets the results. Anyone can wire up a vector database and get "se

Nothing happened. That is the strange part. No deploy. No pull request. Nobody touched the prompt. Your agent ran the way it always ran on Friday, and it runs on Monday, and every dashboard is green. Then a ticket comes in about an answer nobody on your team would have written, and you go looking for the change that caused it, and there is no change on your side. There was a model upgrade. It is the only change to your system that you did not make, cannot find in your own git history, and usually cannot roll back on your own schedule. It is also the one most likely to be announced to you as good news. Why a model upgrade does not look like a bug Because it is not one. The new model really is better. Better on reasoning, better on code, better on the evaluations the lab published beside it, and probably better on yours too, if what you measured was the average. Better and same are different words. Your product was not built on the average. It was built on a specific set of behaviours you watched, liked, and then quietly encoded into everything downstream: how long the answers run, how much the thing hedges, which tool it reaches for first, what it does when a request is vague. None of that appears in release notes. All of it can move. And when it moves, nothing throws. There is no stack trace for "this answer is now worse in a way a customer will notice." Your tests keep passing, because your tests check that the JSON parses and the fields are there, and the JSON still parses and the fields are still there. The three things that actually move Shape. Answers get longer, or shorter, or start opening with a summary they never used to open with. Harmless, right up until something downstream was written against the old shape. Tool choice. The agent develops a new favourite first move. It takes six calls to do what used to take three, or it stops calling the tool you built for it because it has decided it can answer from memory. This one usually reaches the bill before it

I trained a 250M parameter model from scratch on 30B tokens of fineweb. It’s quantized to under 2 bits so the whole deployment is 60 MB and it needs about 80 MB of RAM to run. Runs around 400 tok/s on a normal laptop CPU, no GPU needed. How the long context works: the most recent 2048 tokens stay in fp16 like a normal KV cache. Everything older gets compressed to 1 bit and written to disk, about 320 bytes per token, so 1 million tokens of history is roughly 320 MB on disk. From the start the model was trained to retrieve from that disk cache, up to 100M tokens. Due to a limited budget it wasn’t trained to reason over those tokens, only retrieve and answer from them. Language modeling quality of the base model, measured on held-out English web text that was never seen in training (educational web pages, 2,048 token windows): cross entropy 3.15 nats per token, perplexity 23.3, 0.99 bits per byte. The vocabulary is also not a normal embedding table. Every token is a fixed 512-bit code, 8.4 MB for all 131k tokens, zero trained parameters. I tested it on WordSim-353 (human word similarity ratings): my table scores 0.619 Spearman correlation vs 0.029 for random codes. Test script is in the repo. Some outputs (settings included so you know I’m not cherry picking, all reproducible from the repo): “Explain photosynthesis in two sentences.” (greedy) Photosynthesis is a process in which plants convert sunlight into chemical energy, which is then used to produce oxygen and other chemicals. This process is called photosynthesis. “Write a short poem about the sea.” (temp 0.25, top-k 30, rep 1.15, seed 2) The waves had swept over, and they were crashing against each other like rocks on top of one another. The wind was strong but not very gentle as it tried to push them towards their destination without lifting any weight or pulling away from those who stood in front of her with a stiff smile that made the sea look even more majestic than before. “What is the serial number of devic

Taking the right medication at the right time is more than just a routine—it's a critical part of healthcare. However, for the elderly or those with complex prescriptions, "pill fatigue" is real. Mistakes happen. In this tutorial, we are diving deep into Computer Vision , Edge AI , and IoT to build a real-time pill identification and reminder system. We will leverage YOLOv8 for multi-pill detection and semantic segmentation, deploy it on a Raspberry Pi , and use MQTT to trigger physical alarms or notifications. Whether you are looking to master real-time object detection , explore embedded AI implementation , or build a life-saving IoT device , this guide has you covered! The Architecture: From Vision to Action 🏗️ The system follows a classic Edge-to-Cloud (or Edge-to-Local) pattern. The Raspberry Pi acts as the brain, processing image frames locally to ensure privacy and low latency. graph TD A[Raspberry Pi Camera] -->|Video Stream| B[OpenCV Preprocessing] B --> C{YOLOv8 Engine} C -->|Detection/Segmentation| D[Logic Layer: Check Schedule] D -->|Match/Mismatch| E[MQTT Broker] E -->|Publish Topic| F[Physical Alarm / Buzzer] E -->|Status Update| G[Mobile App/Dashboard] D -->|Log Data| H[Local Database] Prerequisites 🛠️ To follow along, you'll need: Hardware : Raspberry Pi 4B/5 (8GB recommended), Camera Module (V2 or HQ). Tech Stack : YOLOv8 : For state-of-the-art segmentation and detection. OpenCV : For image manipulation. Paho-MQTT : For the messaging protocol. Ultralytics : The framework powering our model. Step 1: Training the YOLOv8 Segmentation Model While YOLOv8 is famous for object detection, we use Semantic Segmentation here to precisely calculate the area and shape of pills, which helps distinguish between very similar-looking tablets. from ultralytics import YOLO # Load a pretrained model model = YOLO ( ' yolov8n-seg.pt ' ) # Train the model on our custom pill dataset # Assume we have a 'pills.yaml' defining classes: 'aspirin', 'vitamin_c', etc. results = mo

Gen AI Academy APAC — Track 1 (AI Agents with Gemini, ADK, and Cloud Run) Why I built this I lead a customer service team of 25 agents at Amazon, handling both buyer-side and marketplace seller support. A big part of my job is reviewing escalated cases — calls or chats where a customer asked for a supervisor — and figuring out why they escalated in the first place. Was it a policy gap? A training issue? A system limitation nobody flagged? Right now, that review is manual. Every escalation gets read, tagged, and turned into a coaching note by a human — usually me, or one of my leads. It works, but it doesn't scale well, and patterns across dozens of cases are easy to miss when you're reviewing them one at a time between everything else on your plate. So for Track 1 of the Gen AI Academy APAC program, I built an agent that does the first pass of this analysis automatically: read an escalation summary, classify the root cause against a standard taxonomy, flag whether it looks like a repeat pattern, and draft a coaching note — the same way I would, just faster and more consistently. What it does The agent takes a case summary like this: Customer requested a refund for a damaged item outside the standard return window. Agent denied it citing policy; customer says a rep last month approved a similar exception for someone else. And returns a structured analysis: { "root_cause_category" : "policy_misapplication" , "severity" : "medium" , "is_likely_repeat_pattern" : true , "pattern_reasoning" : "Inconsistent policy application across agents suggests a training or documentation gap rather than an isolated error." , "coaching_note" : "..." } It's built on Google's Agent Development Kit (ADK) with Gemini as the underlying model, and deployed as a live service on Cloud Run . The agent has one tool — a lookup function for the standard root-cause taxonomy — which keeps the categories consistent and easy to update without touching the core prompt. For batch review, I also built a

So got selected for a research internship at MSR, how good is the quality of work and how useful is it to move to Applied sciences or research sciences position at other FAANG companies after the internship. And any perks and other benefits that interns get during microsoft internship? Any tips will be appreciated. Specifically to get into AS at amazon , does this boost my chances? I'll be joining as an SDE-1 at amazon after 6 months so planning to apply internally once I join. So what else should I do to improve my chances to go to AS. submitted by /u/Fuzzy-Pool2415 [link] [留言]

LLMs are too verbose and with a black box model the only things you control are what goes in and how you tell it to write back. Yesterday Claude Code shipped a "concise output style" where Claude keeps things short. We already have a paper out about this! We tested both channels, shortening the input prompt versus telling the model to output answer shorter, on the same questions across five reduction levels, and scored cost, accuracy, and whether the shortened text still matched what the model would have said unconstrained. We also evaluated GPT-4o, GPT-5.4, Claude Haiku 4.5, Claude Sonnet 4.6, Qwen2.5-VL-7B, Qwen3.5-9B, DeepSeek-R1-Distill, Gemma-4-E4B, and Kimi-K2.6 + benchmarked on five short answer datasets + a eleven-language output run (English, German, Spanish, French, Swahili, Chinese, Japanese, Russian, Bengali, Thai, Telugu) + a longer-form summarization test. (1) Shortening the output saved money while keeping accuracy about the same, about 1.5x cheaper on average and up to 3x in the best case across the API models. It worked across languages too! (2) Shortening the input prompt did the opposite. It cost up to 96% more on the worst benchmark, because the model just answers longer to fill in for what you cut and accuracy drops. You pay more and get worse answers :( (3)Output tokens cost more than input tokens, so prompting for fewer output tokens would save costs with short single turn tasks (4) When the shortened output is correct, about half the time the text no longer matches how the model would have reasoned without the constraint. Which is probably fine if you only care about the final answer With providers now offering concise options, we can't see how they're charging for it, so we don't know if it actually saves you cost. But if you control the prompting yourself via the API, you actually do save!! Paper https://www.alphaxiv.org/pdf/2606.24083v1 Code + data https://github.com/danielle34/cavewoman submitted by /u/ibubbles34 [link] [留言]