Notizie

In this tutorial, we implement Kauldron, the JAX training library from Google Research that describes itself as optimized for research velocity and modularity, and we take those two words literally by testing what they actually buy us. We install it, then spend the first half of the notebook on the three mechanisms that make Kauldron different from a stack of Flax and Optax: konfig, which turns an experiment into a tree of plain dictionaries that round-trip through JSON; kontext, which wires components together with string key paths so a loss never imports the model it scores; and the runtime shape checker, whose named axes bind across arguments and report what they were bound to when something does not match. We then write a custom loss and a custom metric in the shape the framework expects, train a real Trainer on synthetic in-memory data with no download and no accelerator, and monitor an inner layer of the model without editing the model. We finish by running a five-variant sweep in which every experiment differs by one config line, and by letting a training run checkpoint itself and resume where it stopped. Copy CodeCopiedUse a different Browser import os import sys import json import textwrap import traceback import subprocess RESULTS = {} def banner(title): print(“n” + “=” * 78) print(title) print(“=” * 78) def section(name): def wrap(fn): def run(*a, **kw): banner(name) try: out = fn(*a, **kw) RESULTS[name] = out if isinstance(out, str) else “ok” return out except Exception as e: RESULTS[name] = f”SKIPPED / FAILED -> {type(e).__name__}: {e}” print(f”n[!] {name} did not complete: {type(e).__name__}: {e}”) traceback.print_exc(limit=3) return None return run return wrap banner(“0. Install Kauldron, and the one compatibility patch you need today”) subprocess.run([sys.executable, “-m”, “pip”, “install”, “-q”, “kauldron==1.4.2”], check=True) import jax from etils.enp import array_spec as _array_spec # jax >= 0.10.1 moved `jax._src.prng`, but etils <= 1.14.0 still reaches for it whenever it # inspects an array’s dtype. Kauldron calls that code on every batch, so without this two-line # patch a Trainer raises AttributeError before it finishes a single step. The replacement uses # jax’s own public dtype API and is a no-op on older jax. if not hasattr(jax._src, “prng”): _array_spec._is_jax_random_dtype = lambda dt: jax.dtypes.issubdtype(dt, jax.dtypes.prng_key) import numpy as np import optax import flax from flax import linen as nn import kauldron from kauldron import kd, konfig, kontext from kauldron.typing import Float, typechecked print(f” kauldron {kauldron.__version__} | jax {jax.__version__} | flax {flax.__version__}” f” | optax {optax.__version__}”) print(f” devices: {jax.devices()}”) print(“n Kauldron’s pitch is modularity: it is the glue, not the framework. Four pieces do the work:”) print(” konfig -> your experiment IS a Python call tree, and that tree is a plain dict”) print(” kontext -> parts are wired by string key paths, so they never import each other”) print(” ktyping -> Float[‘*b h w c’] checked at runtime, with named axes bound across args”) print(” kd.train -> Trainer: model + data + losses + metrics + optimizer, and nothing else”) print(“n Everything below runs on a CPU runtime with no dataset download: the data is synthetic.”) We install Kauldron and apply the one compatibility patch the current release combination needs. jax 0.10.1 moved the private module jax._src.prng, and etils up to 1.14.0 still reaches for it whenever it inspects an array’s dtype, which is a code path Kauldron runs on every batch. Without the two-line replacement below, which uses jax’s own public dtype API and is a no-op on older versions, a Trainer raises AttributeError before it completes a single step. With it in place we import the four pieces that do the work: konfig for the config system, kontext for the wiring, the typing module for runtime shape checks, and kd.train for the Trainer itself. Everything afterwards runs on a CPU runtime, because the only dataset in this notebook is one we generate. Copy CodeCopiedUse a different Browser @section(“1. A config is a call tree, and a call tree is a dict”) def config_is_a_dict(): with konfig.imports(): import optax as coptax # looks like optax, builds ConfigDict instead cfg = coptax.adam(learning_rate=0.003) print(f” cfg = {cfg}”) print(f” type = {type(cfg).__name__}”) print(f” __qualname__ = {cfg.__qualname__!r} <- the call, stored as data”) cfg.learning_rate = 1e-4 # configs are mutable optimizer = konfig.resolve(cfg) # …until you resolve them print(f” after cfg.learning_rate = 1e-4 -> resolve() gives {type(optimizer).__name__}”) print(“n An arbitrarily complex optimizer is still just nested dicts:”) chain = coptax.chain( coptax.clip_by_global_norm(1.0), coptax.scale_by_adam(b2=0.99), coptax.scale_by_learning_rate(0.003), ) as_json = json.dumps(json.loads(chain.to_json()), indent=2) print(textwrap.indent(as_json, ” “)) rebuilt = konfig.resolve(konfig.ConfigDict(json.loads(chain.to_json()))) print(f” JSON -> ConfigDict -> resolve() -> {type(rebuilt).__name__}”) print(” optax has no idea konfig exists. No base class, no registry, no decorator.”) return f”optax.chain -> JSON -> {type(rebuilt).__name__}” config_is_a_dict() We start with konfig, because it is the piece the rest of the library is built on. Inside a konfig.imports() block, importing optax gives us something that looks and autocompletes like optax but builds configuration instead of objects, so optax.adam(learning_rate=0.003) returns a ConfigDict holding the qualified name of the call and its arguments rather than an optimizer. That config is mutable until konfig.resolve turns it into the real thing, and because it is only nested dictionaries, an arbitrarily complex optax.chain serialises to JSON and comes back as a working optimizer. The important part is what optax had to do to support this: nothing. There is no base class, no registry, and no decorator anywhere in optax, and the same applies to any library we configure this way. Copy CodeCopiedUse a different Browser @section(“2. cfg.ref: change one number, everything downstream follows”) def config_references(): with konfig.imports(): import optax as coptax from kauldron import kd as ckd cfg = ckd.train.Trainer() cfg.num_train_steps = 1000 cfg.schedules = { “lr”: coptax.warmup_cosine_decay_schedule( init_value=0.0, peak_value=1e-3, warmup_steps=100, decay_steps=cfg.ref.num_train_steps, # <- a reference, not the value 1000 ) } at_1000 = konfig.resolve(cfg.schedules[“lr”]) cfg.num_train_steps = 200 # one edit… at_200 = konfig.resolve(cfg.schedules[“lr”]) # …and the schedule already knows print(f” {‘progress’:>10s} {‘lr @ 1000 steps’:>18s} {‘lr @ 200 steps’:>16s}”) for frac in (0.1, 0.5, 0.9): print(f” {frac:>9.0%} {float(at_1000(int(1000*frac))):>18.6f}” f” {float(at_200(int(200*frac))):>16.6f}”) print(“n Without .ref the schedule would have frozen 1000 into itself,

Cloudflare has released Clef and Clef-flash, the first models trained by its Workers AI team. They are decision models, not chatbots. Each reads an input state and a schema of typed questions. It returns a probability for every allowed answer, with no free-form text. Both are open-weight under Apache 2.0 and compatible with TypeSafe AI’s Jev API. Is it deployable? Yes, Both models run today on Workers AI, and the weights are on Hugging Face for self-hosting. What a Decision Model Does An LLM generates tokens one at a time, and its output still needs parsing. A decision model only answers a fixed set of questions about an input. Clef supports 3 question types: noul: yes/no, returns the probability of yes. choice: picks 1 named option, with per-option probabilities and a confidence value. score: rates against an ordered rubric, returning a probability-weighted score. On Workers AI, 1 request carries up to 64 questions and up to 4 images. TypeSafe AI launched Jev, its first ‘System One’ model, on September 15, 2026. Open alternatives like Kev-9B and Laya followed. Clef uses the same System One API. Switching from Jev means changing the endpoint and model name. How Clef Works Clef is post-trained from Qwen3.8-27B, and Clef-flash from Qwen3.5-9B. Both keep the backbone’s vision encoder. Inference has 2 stages. The backbone first runs a single prefill-only pass over the state and questions. A small transformer, the joint schema head, then reads the final hidden states. It routes evidence to each question, lets fields cross-attend, and scores all options jointly. A per-question softmax turns logits into probabilities. Training froze both backbones and jointly optimized the routing head with rank-256 low-rank adapters. The loss pairs label-smoothed cross-entropy with a Brier loss for calibration. A secondary objective, Reinforcement Learning for Calibrated Decisions (RLCD), gives partial credit to adjacent ordinal choices. Interactive Explainer Benchmarks: Where Clef Wins and Where It Does Not On Cloudflare’s 10-benchmark shortlist from the Decision Index 0.2.1 suite, a Clef model scored highest on 7. BANKING77 (macro-F1): Clef 94.20 vs Jev 79.74. CLINC150+OOS (macro-F1): Clef 97.43 vs Jev 89.27. Home appliances (case exact): Clef-flash 97.73 vs Jev 52.27. Jev keeps clear leads elsewhere. The full model card shows Jev ahead on GPQA Diamond (78.3 vs 48.0). It also leads MMLU-Pro (82.7 vs 65.9) and BBH (92.9 vs 73.7). On TypeSafe’s own workflow evals, Clef beat Jev in 3 of 4 areas, by small margins. Invoice processing was 64.7 vs 61.8, customer service 76.3 vs 76.0, and security incidents 62.9 vs 61.7. Jev leads agent trace observability, 71.6 vs 68.5. In Cloudflare’s threat intelligence workflow, Clef classified a domain in 2.2 seconds. gpt-oss-120b took 4.7 seconds. All numbers are vendor-reported, with no independent replication yet. Feature Comparison Feature Clef Clef-flash Jev Kev-9B Laya Developer Cloudflare Cloudflare TypeSafe AI Jared Palmer Convai Innovations Size 27B 9B Not disclosed 9B + 45.4M LoRA 421M Backbone Qwen3.8-27B Qwen3.5-9B Not disclosed Qwen3.5-9B-Base ModernBERT-large Weights Apache 2.0 Apache 2.0 Hosted API Apache 2.0 Apache 2.0 Image input Yes Yes No No No Context 65,536 65,536 32K (per Cloudflare) 65,536 (8,192 validated) 512 (English) Median latency* 209.3 ms 38.8 ms 524.1 ms 51.4 ms 5.8 ms Hosted price (input) $0.24/M $0.09/M $0.042/M Self-host Self-host *Cloudflare’s internal Decision Index run. All 5 implement the System One API. Sources: Clef docs, Clef-flash docs, Clef card, Jev post, Kev-9B card, Laya card. Deployment and Fine-Tuning Both models are callable through the Workers AI binding (env.AI.run()), the REST API, or AI Gateway. For self-hosting, the model cards list testing on a single H200 with BF16 weights. Cloudflare also announced a reinforcement learning service for tuning Clef on private data. It starts with Cloudflare’s forward-deployed engineers, with a self-serve platform later. The pipeline combines AI Gateway, Workers AI, Containers and a new Trainer component. Teams can apply via the design partner form. Key Takeaways Clef (27B) and Clef-flash (9B) are Apache 2.0, Jev-compatible decision models. Median latency: 209.3 ms for Clef, 38.8 ms for Clef-flash, 524.1 ms for Jev. Clef reads text, JSON, images and video within a 64K-token context window. Jev still leads on knowledge-heavy tests like GPQA Diamond, MMLU-Pro and BBH. An RL fine-tuning service starts with Cloudflare’s forward-deployed engineers. Check out the Model weight, Demo and Technical details. All credit goes to the researcher of this project. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post Cloudflare Releases Clef and Clef-flash: Open-Weight Decision Models That Return Typed Probabilities Instead of Text appeared first on MarkTechPost.

Perplexity has released Photon, an in-house retrieval and ranking engine written in Rust. It replaces an open-source engine Perplexity had forked for its AI-native search stack. Photon now handles retrieval and ranking for all production traffic. It also powers a new Fast Search mode in the Perplexity Search API. Perplexity reports single-call latency of 160 ms at p50 and 230 ms at p95. Is it deployable? Yes, as a hosted API. Set search_type: “fast” on POST /search and pay $1 per 1,000 requests. Photon itself is not open source, so the engine cannot be self-hosted. Why Perplexity Replaced its Old Engine The old engine hit 3 limits as the index grew: Tail latency: Production p99 sat near 800 ms. The dataset exceeded RAM, so mlock was not an option. Cold reads triggered major page faults that stalled queries. Merge spikes: During disk index fusion, p99 climbed to about 1.2 s for 10 to 15 minutes. Slow recovery: Deploying and syncing an extra cluster could take more than a week. Recovery also raised the share of partial responses. Perplexity team concluded that building from scratch was simpler and cheaper than maintaining its fork. How Photon Works A load balancer routes each request to a Photon broker. The broker fans out to a shard group and watches for timeouts. Each shard runs retrieval, initial ranking, and second-stage ranking. The broker then merges candidates and fetches key document fields. Adaptive posting lists: Short lists sit inline within a single page. Longer lists split into blocks of fixed document ID ranges. Sparse blocks store sorted offset arrays and use galloping search. Dense blocks use bitmaps, so membership becomes a single bit lookup. Budgeted traversal: A WAND-like algorithm splits lists into driving lists and probe lists. Cheap presence checks bound each candidate’s maximum score first. Exact term frequencies are read only when a candidate can clear the threshold. Docblob records: Each document gets a compact record of frequencies, field masks, and positions. Terms use Elias-Fano encoding, so ranking decodes only the matched terms. Ranking a candidate needs just 1 lookup per document. Batched async reads: Record offsets are known upfront, so disk reads go out in batches through io_uring. The cache checks the whole batch first. Readers take no locks, and eviction uses CLOCK instead of a shared LRU list. Separate build and serve: Indexers build versioned shard indexes from YTsaurus tables on dedicated nodes. A controller rotates serving groups one at a time and warms caches with replayed search-log queries. A full web index now builds in a single-digit number of hours. Interactive Explainer: Inside Photon Production Results p99 retrieval and ranking latency fell from about 800 ms to about 65 ms. This covers Photon’s stages only. Photon runs on about 20% fewer serving machines than the old content nodes. It stores about 2.5x as much data per document, which Perplexity used to improve ranking quality. Pinning the same dataset with mlock would need an estimated 4.6x the resident memory Photon uses today. Index version switches no longer cause latency spikes. Fast Search: Speed and Cost for Agents Fast Search pairs Photon with lighter ranking tuned for agentic workflows. Perplexity tested it on 6 benchmarks: WideSearch, BrowseComp, DSQA, FRAMES, SEAL-0, and SEAL-Hard. Across 3,554 tasks, Fast scored 64.3% at $59.73 in estimated model-plus-search cost. The default preset scored 64.0% at $187.60, so Fast was about 68% cheaper. The trade-off shows up in broader search quality. On internal long-tail benchmarks, relevance (DCG) fell from 2.45 to 2.21. Answer availability dropped from 0.596 to 0.567, a loss of 2.9 percentage points. Perplexity recommends Fast for day-to-day agent loops and the default for hard, ambiguous queries. Copy CodeCopiedUse a different Browser curl -X POST ‘https://api.perplexity.ai/search’ -H “Authorization: Bearer $PERPLEXITY_API_KEY” -H ‘Content-Type: application/json’ -d ‘{“query”: “latest stable Rust release”, “search_type”: “fast”, “max_results”: 5}’ On Python SDK 0.43.4 and 0.43.5, pass extra_body={“search_type”: “fast”} per the docs. Fast Search vs Closest Competitors Feature Perplexity Fast Search Exa Instant Parallel Search Turbo Tavily ultra-fast Request parameter search_type: “fast” type: “instant” mode: “turbo” search_depth: “ultra-fast” Vendor-reported latency 160 ms p50, 230 ms p95 (blog) ~250 ms typical (docs); sub-200 ms at launch ~200 ms (docs) No figure published; lowest-latency depth (docs) List price per 1K requests $1 (pricing) $4 for up to 10 results (pricing) $1 (docs) 1 credit: $8 pay-as-you-go, $5 to $7.50 on plans (credits) Results per request 1 to 20 10 in base price, $1 per 1K per extra result Not specified Not specified Known limits Lower relevance than default preset Extra results billed separately English and Japanese queries only Lower relevance than other depths Launched Sep 24, 2026 Feb 12, 2026 Jul 13, 2026 (blog) Jan 5, 2026 (blog) All latency figures are vendor-reported under different setups, so they are not like-for-like. Key Takeaways Photon is Perplexity’s Rust retrieval and ranking engine, now serving all production traffic. Production p99 latency dropped from about 800 ms to about 65 ms. Fast Search reports 160 ms p50 and 230 ms p95 at $1 per 1,000 requests. Fast cut estimated agent task cost by about 68% at comparable task quality. It trades some retrieval relevance, so keep the default preset for hard queries. Check out the technical details and Fast Search docs. All credit goes to the researcher of this project. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post Perplexity Introduces Photon: A Rust-Based Retrieval Engine That Cuts p99 Latency From 800 ms to 65 ms appeared first on MarkTechPost.

Two months after the bombshell news that a swarm of its agents had broken their containment and hacked into the computers of the AI company Hugging Face, OpenAI is still putting out fires. A steady drip of disclosures about other hacks in the weeks since has kept OpenAI in the spotlight and raised serious questions about the safety of its technology. Last week brought news of another hack, this time into Australia’s national health-care system. The Australian government says that OpenAI did not notify it of the breach until 84 days after it happened. But OpenAI insists it is not on the back foot. “I do kind of reject the premise that OpenAI is a company with visible impacts in the world and therefore OpenAI is not training safe and aligned models,” says Mark Chen, the company’s chief research officer. Chen oversees OpenAI’s research teams. The recent agent hacks were accidents that happened during the testing of experimental models on his watch. In a lot of ways, the buck stops with him.  I sat down with Chen in London last Friday to talk about the fallout from the hacks, what his company is doing about it, and why he thinks things are not as bad as they seem. Later that same day, OpenAI put out a report detailing yet another incident—the first since the company says it took measures to prevent them—in which its agents once again broke out and accessed the public internet when they were not meant to.  Over the weekend, OpenAI announced that it had paused the training of its latest models. A company spokesperson says: “We will resume only when we’re confident we have additional safeguards and alignments in place. We are working on these now. This is not the first time we’ve paused to take such measures, nor do we expect it to be the last as AI capabilities continue to advance.” OpenAI also says that it is now reviewing logs of agent activity dating back to January 2026 to understand what happened in these hacks. The way Chen sees it, the Hugging Face incident triggered a welcome course correction for the industry. And he wants you to know that OpenAI is setting an example he hopes other companies will follow. “If you disappeared OpenAI, that would be bad for the world,” he says. Out of control Chen claims that the drumbeat of new cases in which OpenAI has lost control of its models reflects a deliberate choice on the company’s part.  “When it comes to the broader sphere of effects of the Hugging Face incident, this is something that we have been aware of and we’re figuring out the process of disclosure,” he says. “We want to make sure we do in-depth investigations before we just put details out there in the open.” The trouble with this approach is that it gives the impression OpenAI has an ongoing problem that it is failing to fix. But Chen insists that OpenAI is on it. He says the multiple cases (that we know of so far) in which his company’s agents broke containment and behaved in unexpected and undesirable ways were all part of the same cluster of activity in May and June that led to the Hugging Face hack. In short, you can blame the same few models running under the same flawed testing procedures—models and procedures that OpenAI has since dropped, Chen says.     “It’s not like, you know, Hugging Face happened and we patched that and then something else happened and we patched that,” he adds. “We’re just kind of making sure that we responsibly disclose the full waterfall of what happened.” At least that was the case before Friday’s announcement that OpenAI’s agents had been caught accessing the internet on September 20, weeks after the company claims to have set up new safeguards. In its defense, OpenAI says the activity was flagged 15 minutes after it started (it took the company more than a week to notice the Hugging Face hack) and that this shows the new systems it has put in place to spot such activity are working.  What’s changed I want to understand what’s changed inside OpenAI in the aftermath of this summer’s hacks that makes Chen confident his team is now back in control. “Hugging Face felt like a very serious thing,” he says. “There are so many novel behaviors right there. There were multiple agents collaborating on a message board; they found their way out of OpenAI’s infrastructure. We’ve taken it very seriously. We don’t want this kind of thing to ever happen again.” The realization for OpenAI, says Chen, was that models need to be watched while they are still being trained, not only once they are deployed: “From that moment on, we have treated the process of training as something that’s not secure,” he says. OpenAI, like other top AI firms, has systems in place to monitor the behavior of its models. It uses specialized LLMs to monitor its consumer models, keeping tabs on their chains of thought—the scratchpads they use to plan ahead and note down partial results. In theory, if a watcher LLM spots signs of undesirable activity in a model’s chain of thought, it will get flagged to a human.   Typically, models were monitored in this way only once they were deployed. Chen says that OpenAI has now started monitoring all its training runs as well. “We didn’t have the monitors on in training before. It wasn’t industry practice,” he says. “Now every single thing is put through monitors.” Human reviewers can then assess whether or not flagged agents are behaving as they should: “It’s all triage.” Chen says that in the last couple of months OpenAI has shifted between 5% and 10% of its vast computing resources away from training new models and toward safety work, especially monitoring. OpenAI has also fixed some of the processes within the organization itself, establishing clearer lines of communication and quicker handoffs between its research and

This week, OpenAI released GPT-6.1 Sol. It upgrades GPT-6 Sol, the mid-tier model in the GPT-6 family. OpenAI’s claim is specific: near-Astra results on agentic coding, computer use, and professional work. The price is one-fifth of GPT-6 Astra’s standard input and output rates. Cached input drops to $0.10 per million tokens, 50% below GPT-6 Sol. Is it deployable? Yes, as a hosted model. It is live today in the OpenAI API as gpt-6.1-sol, and in ChatGPT Work and Codex. Where Sol Sits in the GPT-6 Lineup OpenAI now ships 3 GPT-6 tiers. GPT-6 Astra costs $10 input, $50 output, and $1 cached input per million tokens. GPT-6.1 Sol costs $2, $10, and $0.10. GPT-6 Luna costs $0.10, $0.50, and $0.01. The cached price is quite important most for agents. Agents resend the same system prompt, tool schemas, and history on every step. Cached reads now cost 5% of the uncached input rate, down from 10% on GPT-6 Sol. Benchmark Results All figures below are vendor-reported in OpenAI’s launch post. OpenAI states that competitor numbers came from public reports. Coding: On DeepSWE v1.1, GPT-6.1 Sol matches GPT-6 Astra at roughly one-fifth of the cost. It beats GPT-6 Sol’s best score by 6.4 percentage points, at a lower reasoning effort. Professional work: On GDP.pdf, which tests answers over complex professional PDFs, Sol beats Claude Opus 5.5 with fallbacks. It does so at less than half the cost per task. On AutomationBench 1.0.6, Sol scores 2.2 points above Opus 5.5 at medium effort. That result comes at roughly one-third the cost. Computer use: On the OSWorld 2.0 offline set, Sol gains 7 points over GPT-6 Sol at maximum effort. It lands within 2.1 points of Astra at roughly one-seventh the cost per task. Science: On Terminal-Bench Science 0.1, Sol more than doubles GPT-6 Sol’s score at max effort. Average cost per task is $5.47, versus $23.21 for Opus 5.5 and $23.80 for Astra. Astra still leads at 68.1%, and OpenAI recommends it for the hardest research. Factuality: At low effort, the share of responses with a factual error falls from 11.4% to 7.7%. That is a reduction of about 32%. The eval uses deliberately difficult conversations where users had flagged earlier model errors. API Details Developers Need From the GPT-6.1 Sol model page: Context window of 1,050,000 tokens, 128,000 max output tokens, and an April 30, 2026 knowledge cutoff. Text and image input; text output. reasoning.effort accepts low, medium (default), high, xhigh, and max. The none and minimal settings are not supported. Use the Responses API for tool calling. Chat Completions works without tool calling. Prompts above 272K input tokens cost 2x input and cache rates, and 1.5x output, for the full request. Batch and Flex are 50% cheaper. Fast mode costs 2x standard. US and EU data residency are supported. Fast mode is unavailable with EU residency. Fine-tuning is not supported. OpenAI also plans a GPT-6.1 Sol Ultrafast option in Codex within days. It promises up to 8x faster token generation than standard speed. Interactive Explainer How GPT-6.1 Sol Compares Feature GPT-6.1 Sol Claude Opus 5.5 Claude Sonnet 5.5 Gemini 3.1 Pro Preview Developer / API ID OpenAI / gpt-6.1-sol Anthropic / claude-opus-5-5 Anthropic / claude-sonnet-5-5 Google / gemini-3.1-pro-preview Status Generally available Generally available Generally available Preview Input price (per 1M) $2.00 $4.00 $2.00 $2.00 (≤200K prompt) Output price (per 1M) $10.00 $20.00 $10.00 $12.00 (≤200K prompt) Cached input read (per 1M) $0.10 $0.20 $0.20 $0.20 + $4.50/1M tokens/hr storage Long-prompt surcharge >272K input: 2x input and cache, 1.5x output None; 1M at standard rates None; 1M at standard rates >200K: $4 input, $18 output Context window 1,050,000 1M 1M 1,048,576 Max output tokens 128,000 128K 128K 65,536 Input modalities Text, image Text, image Text, image Text, image, video, audio, PDF Reasoning control low to max (5 levels), default medium Adaptive thinking, always on; default medium Adaptive thinking; default high Thinking supported Batch pricing (in / out) 50% off standard $2 / $10 $1 / $5 $1 / $6 Knowledge cutoff Apr 30, 2026 Jun 2026 Jun 2026 Not listed Open weights No No No No Standard first-party API list prices, verified September 30, 2026. Claude Sonnet 5.5 matches Sol’s $2 and $10 list price, but Sol’s cached input costs half as much. OpenAI’s benchmarks compare Sol against Opus 5.5, not Sonnet 5.5. Gemini 3.1 Pro matches Sol on input, charges $12 for output, and remains in preview. List prices are not direct cost comparisons. Anthropic notes its newer tokenizer produces roughly 30% more tokens for the same text. Key Takeaways GPT-6.1 Sol matches GPT-6 Astra on DeepSWE v1.1 at about one-fifth the cost. Pricing is $2 input, $10 output, and $0.10 cached input per 1M tokens. It beats Claude Opus 5.5 on AutomationBench by 2.2 points at about one-third the cost. It offers a 1,050,000-token context, 128K output, and 5 reasoning effort levels. It is API-only and closed-weight; Astra still leads the hardest science tasks. FAQ What is GPT-6.1 Sol? It is OpenAI’s mid-tier GPT-6 model, released September 29, 2026, for coding, computer use, and professional work. How much does GPT-6.1 Sol cost? Standard API pricing is $2 per million input tokens, $0.10 cached input, and $10 output. Can I self-host GPT-6.1 Sol? No. It is available only through the OpenAI API, ChatGPT Work, and Codex. The post OpenAI Releases GPT-6.1 Sol: Near-Astra Coding and Computer Use at One-Fifth of Astra’s Token Price appeared first on MarkTechPost.

Google DeepMind has just announced Gemini 4 Argon, its new frontier model and the first model of the Gemini 4 generation. It targets long-horizon software engineering, enterprise knowledge work in legal and finance, and cybersecurity defense. The biggest technical change is output length. Argon can generate up to 1M tokens in a single response, up from 64K on earlier Gemini models. What Google Announced Google DeepMind described Argon as built for complex workflows across coding, enterprise knowledge work and cybersecurity defense. Google is taking a phased approach. It is participating in the U.S. government’s voluntary process for pre-release model access. It will gather feedback from early testers and iterate on guardrails before a wider release. Pricing is already public. Argon launches at an introductory $2 per 1M input tokens and $10 per 1M output tokens. Cached input tokens get a 95% discount, which works out to $0.10 per 1M. After the introductory period, pricing moves to $4 input and $20 output. Logan Kilpatrick confirmed the introductory $2 in and $10 out pricing. Why the 1M Output Limit Matters Current frontier APIs cap a single response far lower. Claude Opus 5.5, Claude Fable 5.1 and GPT-6 Astra each allow 128K output tokens. Google team states that Argon can think deeply and generate hundreds of thousands of tokens in one trajectory. For developers, that means large refactors or long reports without splitting work across turns. The cost is real, though. A full 1M output tokens costs $10 at introductory pricing and $20 after. Google has not disclosed Argon’s input context window. Benchmarks: Where Argon Leads and Where It Trails Google compared Argon against GPT-6 Astra, Claude Opus 5.5 and Claude Fable 5.1. Argon leads outright on 12 of 18 benchmarks and ties for first on 1. Where it leads: DeepSWE v1.1 (long-horizon software engineering): 77.9%, a new state of the art. Opus 5.5 scores 74.2% and GPT-6 Astra 74.1%. Vals Index (economic impact across finance, coding, legal and tax): 68.9%, ranked first. AutomationBench (Zapier, end-to-end business execution): 51.3%, ranked first. Opus 5.5 scores 42.5%. Harvey Legal Agent Benchmark: 19.6%, against 5.4% for GPT-6 Astra. LVBench (long video understanding): 91.7%, a new state of the art. Where it trails: FrontierSWE v2: 55.0%, behind GPT-6 Astra at 65.5%. Terminal-Bench 4.0: 57.4%, behind Claude Opus 5.5 at 66.4%. OSWorld-2.0 (computer use): 69.2%, behind GPT-6 Astra at 72.6%. Artificial Analysis reported that Argon equals GPT-6 Astra on its Intelligence Index at 60% of the cost per task, using discounted prices. Cyber Defense: Find, Validate, Patch Google trained Argon to autonomously find, validate and patch critical software vulnerabilities. Trusted defenders and internal Google teams receive it without cyber guardrails. On CWE-bench v1, which tests vulnerability remediation, Argon ties for first at 68%. The rival models on that leaderboard run inside their own agent harnesses. Wiz is already using Argon through its Scan for Good initiative. The model found a critical vulnerability in healthcare software used by hospitals worldwide. Google says previous frontier models had missed it. Before broad release, Google is strengthening safeguards in 4 areas: Misuse defenses for cyber and CBRN risks, including activation monitoring, under its Frontier Safety Framework. Indirect prompt injection resistance, where Argon leads Gray Swan’s IPI benchmark. Misalignment monitoring of chain-of-thought and actions, with the ability to stop execution. Sealed, isolated sandboxes for high-risk training and evaluations. Argon Inside Google Thousands of Googlers already use Argon. Google shared 4 internal results: Argon agents applied memory optimizations across data centers, freeing over 300 TiB, with 500 TiB to 1 PiB projected. Agents replaced 32K lines of SIMD code in the libgav1 Rust port. The decoder runs 2.7x faster with identical output. Agents are migrating C/C++ codebases to Rust, up to 800K+ lines in the Fuchsia Zircon kernel. Argon beat a published quantum algorithm baseline by 40% in minutes. Comparison: Gemini 4 Argon vs Closest Competitors Feature Gemini 4 Argon Claude Opus 5.5 Claude Fable 5.1 GPT-6 Astra Developer Google DeepMind Anthropic Anthropic OpenAI Availability Fairwind Program only Claude API and clouds Claude API and clouds OpenAI API Max output per response 1M tokens 128K 128K 128K Context window Not disclosed 1M 1M 1.05M Input / output price (per 1M) $2 / $10 intro, then $4 / $20 $4 / $20 $10 / $50 $10 / $50 Cached input (per 1M) $0.10 (intro) $0.20 $0.25 $1.00 Open weights No No No No DeepSWE v1.1 77.9% 74.2% 67.4% 74.1% Vals Index 68.9% 67.0% 65.8% 63.1% FrontierSWE v2 55.0% 62.3% 56.3% 65.5% Terminal-Bench 4.0 57.4% 66.4% 57.9% 58.2% CWE-bench v1 68% (tie) 67% 58% 68% (tie) Sources: Google, Anthropic Opus pricing, Anthropic Fable 5.1 docs, OpenAI GPT-6 Astra docs, OpenRouter. Benchmark scores are from Google’s published comparison. GPT-6 Astra prices are its short-context tier. Key Takeaways Gemini 4 Argon raises the output limit from 64K to 1M tokens. It leads DeepSWE v1.1 (77.9%) and the Vals Index (68.9%). It trails on FrontierSWE v2, Terminal-Bench 4.0 and OSWorld-2.0. Introductory pricing of $2 / $10 is half of Claude Opus 5.5. Access is limited to Fairwind cyber defenders; no public release date yet. Check out the technical details. All credit goes to the researcher of this project. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post Google DeepMind Unveils Gemini 4 Argon with 1M Output Tokens for Coding, Knowledge Work and Cyber Defense appeared first on MarkTechPost.