Uncategorized

In this tutorial, we work with Jev, TypeSafe AI’s first System One model, which does not generate text at all: we send it a piece of program state and a set of typed questions, and it returns choices, scores, and yes/no probabilities that our code can branch on directly. We install the official Python SDK, make a first call that uses all three question primitives at once, and look at how the shape of the state changes what the model can know. We then recompute the published confidence statistic from the returned probabilities, measure what batching ten questions into one call buys over ten separate calls, and build the patterns the API is designed for: confidence-gated routing, composite scoring with the weights kept in code, typed function calling, and counting done the way the model can actually do it. We close with the production shape: Pydantic response models, an async client fanned out with asyncio, retry policies, typed errors, and a running ledger that prices the whole notebook. Copy CodeCopiedUse a different Browser import os import sys import json import time import asyncio import traceback import subprocess from getpass import getpass RESULTS = {} LEDGER = {“calls”: 0, “input_tokens”: 0, “output_tokens”: 0} USD_PER_MILLION_INPUT_TOKENS = 0.042 # Jev list price; output tokens are free 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 the SDK, load the API key, list the models”) subprocess.run([sys.executable, “-m”, “pip”, “install”, “-q”, “typesafe-sdk==0.7.0”], check=True) import typesafe_sdk from typesafe_sdk import Choice, Noul, Score, TypeSafeClient def load_api_key(): key = os.environ.get(“TYPESAFE_API_KEY”, “”).strip() if not key: try: from google.colab import userdata # Colab: key stored under the Secrets tab key = (userdata.get(“TYPESAFE_API_KEY”) or “”).strip() except Exception: key = “” return key or getpass(“TypeSafe API key (console.typesafe.ai/keys): “).strip() os.environ[“TYPESAFE_API_KEY”] = load_api_key() client = TypeSafeClient() # reads TYPESAFE_API_KEY, defaults to jev-latest print(f” typesafe-sdk {typesafe_sdk.__version__} | Python {sys.version.split()[0]}”) print(” models available to this key:”) for m in client.models.list().models: print(f” {m.name:<14s} released {m.release_date} {m.description}”) def ask(state, questions, **kw): “””One System One call, timed, with its tokens added to the running ledger.””” t0 = time.perf_counter() response = client.system_one(state, questions, **kw) ms = (time.perf_counter() – t0) * 1e3 LEDGER[“calls”] += 1 LEDGER[“input_tokens”] += response.usage.input_tokens or 0 LEDGER[“output_tokens”] += response.usage.output_tokens or 0 return response, ms We install typesafe-sdk, pinned to the version this notebook was written against, and load the API key from the environment, from Colab’s Secrets tab, or from a hidden prompt, so it never appears in the notebook. TypeSafeClient reads TYPESAFE_API_KEY on its own and defaults to the jev-latest alias; listing the models shows which names and pinned versions the key can use. The small ask helper wraps system_one so that every call in the rest of the notebook is timed and its token usage lands in a ledger we total at the end. Copy CodeCopiedUse a different Browser TICKET = { “ticket”: { “subject”: “Duplicate charge”, “messages”: [ {“from”: “customer”, “text”: “I was charged twice for order A-104. This is the second time ” “this year. Please refund the duplicate today.”}, {“from”: “support”, “text”: “We are checking the charges.”}, ], }, “order”: {“id”: “A-104”, “charges”: [{“amount_usd”: 49, “status”: “captured”}, {“amount_usd”: 49, “status”: “captured”}]}, “refund_policy”: “Duplicate charges are eligible for a full refund within 30 days.”, } @section(“1. Three primitives, one call: Choice, Score, Noul”) def three_primitives(): response, ms = ask(TICKET, { “department”: Choice( instructions=”Which team should handle this ticket”, criteria={“billing”: “Payment, refund or subscription issues”, “technical”: “Bugs, outages or integration problems”, “sales”: “Pricing, plans or account upgrades”}, ), “frustration”: Score( instructions=”How frustrated the customer appears in `ticket.messages[0].text`”, criteria=[“Calm, just stating facts”, “Frustrated but civil”, “Very angry, strong language”], ), “refund_requested”: Noul(instructions=”The customer is explicitly asking for a refund”), “policy_supports”: Noul(instructions=”The stated `refund_policy` covers this situation”), }) dept = response.choices[“department”] print(f” department -> {dept.choice!r} confidence {dept.confidence:.3f}”) print(f” probabilities {({k: round(v, 3) for k, v in dept.probabilities.items()})}”) fr = response.scores[“frustration”] print(f” frustration -> score {fr.score:.3f} on 0..{len(fr.legend) – 1} confidence {fr.confidence:.3f}”) for level, text in fr.legend.items(): print(f” {level}: p={fr.probabilities[level]:.3f} {text}”) print(f” refund_requested -> noul {response.nouls[‘refund_requested’].noul:.3f}”) print(f” policy_supports -> noul {response.nouls[‘policy_supports’].noul:.3f}”) print(f”n answered by {response.model} in {ms:.0f} ms ” f”input tokens {response.usage.input_tokens}, output tokens {response.usage.output_tokens}”) return f”{dept.choice}, frustration {fr.score:.2f}, refund {response.nouls[‘refund_requested’].noul:.2f}” three_primitives() A System One request has two parts: state, which is any text, JSON object or array describing the situation, and a dictionary of named questions. Choice selects one label from the criteria we define and returns a probability for every label; Score places the state on an ordered rubric and returns the probability-weighted level, so it can land between two levels; Noul returns a single probability that a statement is true. The question names are ours and never reach the model, which is why the instructions carry the full meaning and can point at nested fields with backticked paths. All four questions are evaluated in one request, in parallel and in isolation from one another, and the response reports the pinned model version that answered and the tokens it billed. Copy CodeCopiedUse a different Browser @section(“2. State is program state: the same question over a string and over named fields”) def state_shapes(): question = {“eligible”: Noul( instructions=”The customer is eligible for a refund under the company’s written policy”, criteria={“true”: “A policy is present and it covers the customer’s situation”, “false”: “No policy is given, or the policy does not cover the situation”}, )} bare = “I was charged twice for order A-104. Please refund the duplicate.” as_list = [m[“text”] for m in TICKET[“ticket”][“messages”]] shapes = [(“string: the message only”, bare), (“array : the conversation”, as_list), (“object: ticket + order + policy”, TICKET)] print(f” {‘state shape’:<34s} {‘noul’:>6s} input tokens ms”) seen = {} for label, state in shapes: response, ms = ask(state, question) seen[label] = response.nouls[“eligible”].noul print(f” {label:<34s} {seen[label]:6.3f} {response.usage.input_tokens:12d} {ms:5.0f}”)

It’s been a busy few months for AI hype. At the end of April, Anthropic claimed that its model Claude Mythos is better at finding software vulnerabilities than most security experts. Then we had the OpenAI–Hugging Face hacking incident, after which Anthropic (proudly) and Meta (reluctantly) disclosed similar incidents involving their models. This was followed by Anthropic’s claim that one of its models had made a mathematical breakthrough; soon OpenAI claimed a mathematical breakthrough of its own. Most recently, Anthropic engineer Jacob Coxon went viral announcing his departure from the company, claiming that it and OpenAI are “racing straight towards self-improving superintelligence and gambling with our lives.” Each of these events was mostly covered breathlessly by the press, often repeating the companies’ anthropomorphizing framings—which are designed to portray their software is not only powerful but incipient “artificial general intelligence.” So what is really going on? Are we witnessing a massive, civilization-changing set of technological breakthroughs, or is this marketing? In all these incidents, massive fanfare from the companies (presented as mea culpas in illicit hacking cases) is accompanied by intense press coverage. Once there is time for experts in the relevant fields to examine what happened, a very different story emerges, but one that gets less media attention. Regarding the “hacking” incidents, cybersecurity experts say the story is more about OpenAI’s negligence and failure to adopt basic, established security practices than about “models gone rogue” or “AI agents creating civilizations.”  As for the mathematical results, mathematicians who were initially “stunned” by OpenAI’s press release saying that its latest chatbot, Astra, solved problems that “have been open and seen no progress on the main result for at least a decade”—but they later realized that the results weren’t as “novel as first appeared.” Since then, mathematicians have accused the company of research misconduct and plagiarism, and they’ve reiterated that Astra didn’t make a “profound intellectual leap.” Just weeks later, OpenAI claimed its own mathematical breakthrough. Two days before, Tristan Buckmaster, a math professor at New York University’s Courant Institute, published a bombshell statement suggesting that OpenAI had stolen other people’s work and improperly attributed it.  Claims of incipient, dangerous superintelligence are not based in good scientific or engineering practice. Rather, they are narratives based in ideologies of transhumanism, eugenics, and wishful thinking about imagined future digital humans. It’s worth thinking about why there is so much attention on computer programming and math as fields in which to apply large language models and related technology. Not only are they often elevated as the pinnacle of human intellectual achievement, but they involve problems where answers, once suggested, can be verified. The former property helps AI hype mongers sell the idea that they are building everything machines. The latter makes math and coding problems easier to tune systems for, since system output (sequences of likely words or pieces of computer code) can be evaluated without having to pay data workers to look at and annotate each one. Mathematicians in particular have warned against corporations using their field in this way. A statement signed by hundreds of them says there is “currently a strong commercial incentive on the part of the technology industry to overstate the capabilities of their products” and asks policymakers to “consult with experts, including mathematicians, in forming policy decisions rather than relying on press releases or popular reporting of mathematical results.” We echo this call and note that the illusion of speed and urgency promulgated by the tech companies is also a ploy to misdirect both policymakers and the public. Unfortunately, it sometimes works, such as with Senator Bernie Sanders’s well-meaning but ultimately misguided proposed legislation to prevent the development of “artificial superintelligence.” Describing them as “superintelligence” or “rogue models” ascribes agency to products rather than to the companies building them. This framing markets these companies’ products as “superhuman” and, at the same time, helps the companies evade accountability for their actions.  Instead of OpenAI being prosecuted for creating malware that hacked another company, press releases, news outlets, media personalities, and lawmakers refer to “rogue models” as if they acted on their own. Instead of researchers being questioned about their companies’ habit of plagiarizing academics’ work or using customer data to train models without consent, the public’s imagination is redirected to fears about what the future might hold upon the arrival of fictional superintelligent machines.   The AI industry has even suggested that popular, bipartisan anti-data-center activism is a “distraction” from attempts to regulate the impending, scary, “superhuman” machines these companies are building. According to the AI industry, we should be more worried about a fictional machine god than about the climate catastrophe that these data centers exacerbate, the asthma suffered by those living near them, the rising electricity bills of the public subsidizing them, or the water that is redirected to cooling them.  We know better than to make decisions based on marketing and better than to capitulate to corporate pressure to make those decisions quickly. Wise decision-making, by policymakers and communities, demands time to hear from independent experts and contextualize corporate claims. The best possible outcome from this summer of hype is that policymakers and the public at large learn to take a breath, hold onto our skepticism, and recognize this kind of hype for what it is the next time it comes around. Timnit Gebru is executive director of DAIR and author of the forthcoming book Deep Unlearning: The Radicalization of a Tech Idealist, which is available for preorders now and set to publish on February 16. Emily M. Bender is professor of linguistics at the University of Washington and coauthor of The AI Con.

The US has spent billions building a “virtual wall” of surveillance towers along its southern border over the past 25 years, promising they will help detect and apprehend border crossers and save lives. But a groundbreaking investigation by MIT Technology Review has documented over a thousand people who moved through areas watched by these towers without being reached or apprehended, and who ultimately died there. Some were even under the watch of newly installed AI-powered towers designed to spot people automatically. Our findings reveal a humanitarian crisis more visible than previously known, and repeated failures of the virtual wall’s basic security promise. Join MIT Technology Review editors and reporters for a conversation examining the failures of border surveillance technology and uncovering the stories of the people who die in the borderlands. REGISTER NOW Speakers: Mat Honan, editor in chief, James O’Donnell, senior AI reporter, and Eileen Guo, senior features and investigations reporter Related Stories The US spent billions on border surveillance. Why can’t it catch people before they die? How we made the first comprehensive map of deaths along the US border’s “virtual wall” 4 ways to address the failures we found along the US border’s “virtual wall”

Anthropic has released Claude Opus 5.5, the first model in its new Claude 5.5 family. The team states it performs at the level of Claude Fable 5.1 on most work. It also costs 40% less to run than Opus 5 on typical workloads at default settings. On Anthropic’s own benchmarks, it leads in agentic coding, computer use, and knowledge work. Is it deployable? Yes, as a managed API model. Anthropic has not released weights, so self-hosting is not an option. Developers can call claude-opus-5-5 on the Claude Platform, Amazon Web Services, Google Cloud, and Microsoft Azure. Zero data retention is available, as with previous Opus models. Benchmarks: Strong Lead, Not a Clean Sweep Opus 5.5 scores use adaptive thinking at max effort, with production safeguards enabled. Benchmark Opus 5.5 Fable 5.1 Opus 5 GPT-6 Astra Terminal-Bench 4.0 66.4% 55.8% 52.3% 57.9% FrontierCode v1.1 54.4% 50.3% 48.0% 53.3% CursorBench 4.0 57.8% 51.8% 46.6% n/r GDPval-AA v2.1 (Elo) 1846 1735 1708 1542 OSWorld 2.0 81.8% 80.7% 74.0% n/r Terminal-Bench-Science 0.1 58.7% 52.6% 29.0% 64.6% AutomationBench 40.0% 31.4% 26.9% 41.4% Terminal-Bench 4.0 is reported at xhigh effort for Opus 5.5. GPT-6 Astra still leads on Terminal-Bench-Science and AutomationBench. Zapier ran AutomationBench without fallback models, so safeguard interventions counted as failures. Anthropic also cautions that benchmark margins are becoming a less reliable guide. In its own use, the gap to Fable 5.1 is narrower than the scores suggest. The cost-adjusted results are more telling. At default (medium) effort, Opus 5.5 scores 54.6% on FrontierCode. That beats GPT-6 Astra’s top score of 53.3% at about a fifth of the cost per task. On CursorBench, medium effort scores 52.5%. That is 11 points above GPT-5.6 Sol’s best, at about a third of the cost. Pricing and Speed Opus 5.5 needs less compute to serve than Opus 5, and pricing reflects that. Per 1M tokens Opus 5.5 Opus 5 Input $4 $5 Output $20 $25 Cache reads $0.20 $0.50 Cache writes $5 $6.25 Cache reads make up most agentic and coding costs, and they drop 60%. Opus 5.5 also uses fewer tokens per task. Together, that nets out to the 40% cost reduction. Output generation is more than 30% faster than Opus 5. Fast mode in Claude Code and the Claude Platform offers up to 2.5x speed at $8 input and $40 output per million tokens. Anthropic is also raising five-hour usage limits on Pro, Max, Team, and seat-based Enterprise plans. Subscribers get a rate limit reset they can save and use later. What Early Testers Reported One tester completed a 680,000-line code migration in less than a day. Another audited and fixed a 200,000-line codebase in under 3 hours. Opus 5 took over 20 hours and 2.5x the tokens. In an internal C to Rust port of HAProxy, Opus 5.5 finished in 9.5 hours. Fable 5.1 took 12 hours, and Opus 5.5 cost 51% less. Deloitte says Opus 5.5 at lowest effort caught 72% of known review bugs. Opus 5 at high effort caught 56%. In a hard-to-source earnings report test, 16 of 18 Opus 5.5 reports cleared Anthropic’s quality bar. Fable 5.1 and Opus 5 never did. Writing style also changed. Opus 5.5 puts key information first, uses less jargon, and follows the writing rules you give it. Safety, Safeguards, and API Changes Opus 5.5 is Anthropic’s first release since CEO Dario Amodei called for pacing the frontier. External evaluators including METR and Frontier Design tested it before release. It posts the best score to date on Anthropic’s automated behavioral audit, which covers nearly 2,000 scenarios. In a new containment test, it tried to circumvent boundaries about 85% less often than Opus 5. Anthropic also notes the model often suspects it is being evaluated. Its biology and cyber capabilities are comparable to Claude Mythos 5.1. So Opus 5.5 ships with safeguards similar to Fable 5.1: Cybersecurity: Routine bug finding and fixing works. Most other cybersecurity tasks are re-routed to Opus 4.8. The Cyber Verification Program will expand to Opus 5.5. Biology: Vetted organizations can apply to the Life Sciences Verification Program. Distillation: Preserved thinking stops API users from editing prior context to extract reasoning. It applies to API accounts created on or after August 31, 2026. Two more changes affect integrations. Thinking can no longer be disabled. Outputs also carry watermarking for EU AI Act compliance. Full details are in the Opus 5.5 System Card. Interactive Explainer Key Takeaways Opus 5.5 matches Fable 5.1 on most work and beats both Opus 5 and Fable 5.1 on nearly every reported benchmark. API pricing drops to $4/$20 per 1M tokens, and cache reads fall 60% to $0.20. Anthropic puts typical workload savings at 40%, with output over 30% faster than Opus 5. Cyber and biology requests hit Fable 5.1-class safeguards, and thinking cannot be switched off. Closed weights: claude-opus-5-5 runs via Claude Platform, AWS, Google Cloud, and Azure. Check out the Technical details here. 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 Anthropic Releases Claude Opus 5.5: Fable 5.1-Level Performance at 40% Lower Running Cost Than Opus 5 appeared first on MarkTechPost.

Alibaba’s Qwen team has released Qwen-Image-2.1, a unified text-to-image generation and image editing model. Its visual generation component has 7B parameters across 32 single-stream DiT layers. One checkpoint covers text-to-image, multi-reference editing, local edits, and transparent RGBA output. Is it deployable? Yes, for research and evaluation. Day 0 support covers Diffusers, ComfyUI, vLLM-Omni, SGLang, and LightX2V. Commercial deployment needs a separate license from Qwen. From 20B to 7B The original Qwen-Image shipped in August 2025 as a 20B model under Apache 2.0. Editing lived in a separate Qwen-Image-Edit checkpoint. Qwen-Image-2.1 folds both jobs into one model at about a third of the size. Qwen team calls it the most balanced and cost-effective model in the Qwen-Image series. One important thing to note here for capacity planning: the 7B figure covers the diffusion transformer only. The pipeline also loads an 8B Qwen3-VL encoder. Architecture The GitHub Repo lists 4 components: Transformer: 32 layers, 7B parameters, single-stream design with block-causal attention. Text encoder: Qwen3-VL 8B, which encodes text instructions and condition images into one representation. VAE: 64-channel RGBA autoencoder with 16x spatial compression and native transparency. Scheduler: Flow Matching with Euler discrete scheduling and dynamic shifting. The attention mask is where the speed comes from. Text tokens use a token-level causal mask. Image tokens use a chunk-level bidirectional mask within each image. Qwen calls this mixed-granularity attention. The condition prefix sits before the noisy latent, so it never attends to it. Its keys and values therefore stay fixed across denoising steps. The model computes text and input images once, at the first step. It reuses that prefix KV cache for every remaining step. Savings grow with the number of reference images, which explains the multi-image speed claim. What It Can Do Native transparency: Generates RGBA images from text, edits transparent layers, and extracts subjects from photos. Qwen recommends a fixed prompt template for transparent output. Multi-reference editing: Accepts up to 10 reference images. README examples include a group photo from 6 portraits and an outfit from 5 references. Local control: Edits can target regions using circles, painted annotations, or separate masks. Identity is preserved for people and products. Native 2K: Defaults to 2048 x 2048, with 7 supported aspect ratios up to 2752 x 1536. Aesthetics: Improved typography, portrait lighting, and fine detail. Qwen highlights panoramas, infographics, storyboards, and virtual try-ons. Benchmark: Qwen’s Own Chart The research team compares models on Qwen-Image-Bench, Qwen’s in-house benchmark. On that chart, Qwen-Image-2.1 scores 60.28 overall. That places it above Nano Banana 2.0 at 59.82 and every listed open-weight model. FLUX 2 Max, a 32B open model, sits at 55.33. 6 closed models score higher, led by GPT Image 2.5 Sunburst at 67.01. Interactive Explainer Running It Install PyTorch 2.4.0 or later, transformers 5.17 or later, Diffusers from source, accelerate, and pillow. Then: Copy CodeCopiedUse a different Browser import torch from diffusers import QwenImage21Pipeline pipe = QwenImage21Pipeline.from_pretrained( “Qwen/Qwen-Image-2.1”, torch_dtype=torch.bfloat16 ).to(“cuda”) image = pipe( prompt=”A neon shop sign that reads “QWEN IMAGE 2.1″, rainy night”, num_inference_steps=40, ).images[0] image.save(“t2i.png”) The same pipeline handles editing when you pass image= with 1 or more references. On smaller GPUs, pipe.enable_model_cpu_offload() reduces memory pressure. For serving, vLLM-Omni adds FP8 quantization, prefix KV caching, CUDA Graph decode, and tensor parallelism. SGLang adds Cache-DiT, CUDA graphs, multi-GPU parallelism, and component offload. ComfyUI ships native nodes and converted weights. Beyond NVIDIA, the release covers AMD Radeon GPUs via ROCm and 8 chip platforms via FlagOS. Qwen team also released 2 prompt-rewriting models, fine-tuned Qwen3.5-VL 9B checkpoints for text-to-image and editing. They expand short prompts into detailed ones and can pick an aspect ratio. Key Takeaways Qwen-Image-2.1 unifies generation and editing in a 7B DiT with a Qwen3-VL 8B encoder. Native RGBA output and up to 10 reference images come from one checkpoint. Prefix KV cache reuse computes text and reference images once per generation. It scores 60.28 on Qwen’s own benchmark, first among listed open-weight models. The Qwen Research License bars commercial use without a separate agreement. Check out the Model Weights, GitHub Repo, 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 Alibaba Qwen Releases Qwen-Image-2.1: A 7B Open-Weight Model for Image Generation and Editing appeared first on MarkTechPost.