Committee

I knew I’d officially become a ‘longevity influencer’ this month when a company called Generation Lab reached out to offer me the chance to write about—and even receive—their new rejuvenation treatment, an injectable combination of two existing drugs which they call 1 Generation. This wasn’t just any antiaging treatment, either. A company fact sheet says that it “blocks the systemic spread of aging in the bloodstream, reawakens the body’s own repair mechanism and restores health and youth to multiple tissues.” The exclusive offer to join a “private cohort” receiving access to the treatment was being “extended to a limited number of people whose judgment on the science we trust, under close physician supervision.” “There’s a long wait list including a lot of celebrities, well-known people, people who you have heard of,” Generation Lab’s CEO Alina Su told me in a conference call. “So we’re super excited to, like, create this drug and [are] letting you know that this first longevity therapeutic in [the] human body is here and it’s actually working.” This was all clearly a marketing campaign and, like most other claims in the world of longevity medicine, probably too good to be true. What’s more, Generation Lab wouldn’t tell me what the two drugs are, making the proposition hard to take seriously. Yet this pitch got my interest. The reason? I am a longtime follower of Generation Lab’s irascible scientific founder, Irina Conboy, a take-no-guff specialist in the bizarre, but scientifically fruitful, practice of joining together the circulatory systems of old and young lab animals. The procedure, called parabiosis, or heterochronic blood exchange, is one of the few things actually proven to make an old animal act younger.  But you can’t go through life attached by the veins to a younger person. So the quest has been to find practical ways to mimic those benefits.  And that is something Conboy says she’s now achieved by hitting on a combination of two existing drugs that produce youthful effects—but without the need for any bodily fluid exchange.  Over the last two months, Conboy has been taking the drug combination and feeling quite a bit better and more energetic, she says. So have a handful of other insiders, including Su, the company’s 26-year-old CEO, as well as Conboy’s husband and scientific collaborator Michael Conboy. The company’s public relations staffer sent me a spreadsheet of the supposed benefits experienced by the participants, including improved vision in a 64-year-old female, longer landscaping sessions for a 59-year-old man, longer badminton games, improved hand grip, better erections than with Viagra, as well as “increased bowel movements.” Obviously, any age-reversal drug that works would be the best-selling product of all time. The problem is that none have ever been shown to do that. And Generation’s approach to evidence raises several red flags. For instance, Su says the company now plans to launch a larger study, involving a hundred or more people. However, others are being offered the drug before firm evidence of a benefit is in. In addition, the trial will be led by longevity doctors who practice alternative medicine. These include Matt Cook, founder of a network of clinics called BioReset Medical. Cook’s clinics offer what I would characterize as unproven treatments, such as stem-cell injections. A 2021 article reported he’d recommended covid-19 treatments designated as “fraudulent” by the FDA. Those included inhaling amniotic fluid from a nebulizer. In a phone call, Cook says he initially agreed to prescribe the combination to Conboy and a few other insiders. (Everyone involved, he says, is a member of the same “happening” Silicon Valley scene around life extension.) “My confidence this was going to work was a zero. Like, I did not believe it was actually going to work,” says Cook. That is because “it’s two safe, generic drugs that are not even longevity drugs.”   But Cook, who also took the combination, says there was an effect. “And I have to tell you, it was the most surprising thing that ever happened to me,” he says. After taking the weekly injections, he experienced a sense of mental clarity that lasted for a day, and then several days. The other subjects, he says, reported a sense of well-being, as well as old aches and pains that evaporated.  “There was a fairly significant broad set of symptoms that doesn’t really match what either of the drugs do,” he says. “So it’s interesting. [But] I have many more questions than I have answers … I still feel like I don’t understand exactly what the mechanism is.” Prior to joining Generation Lab full time in 2025, Irina Conboy had a long career at the University of California, Berkeley, where she made her name via a widely cited series of experiments aimed at learning   whether the characteristics of age, or youth, could be transferred between animals via the bloodstream. In 2005, for instance, she surgically connected two-month-old mice to very aged ones, finding that the old animals’ ability to heal from injury dramatically improved. This suggested that young blood must contain specific, powerful molecular signals capable of restoring the regenerative capacity of an old animal. As researchers zeroed in on candidate signals, several startups, including Elevian, a Harvard spinout, and Alkahest, tied to Stanford University scientists, were able to raise millions to pursue treatments for stroke or Alzheimer’s. However, those efforts still have not hit commercial paydirt. Although it’s clear that young blood is good for old mice, scientists also know the reverse is true: Even a single exchange of plasma from an aged mouse has powerful, negative effects on a younger animal. That means that in the battle of age versus youth, says Conboy, “old blood dominates.”   Conboy next tried a new approach. Instead of giving old animals young blood, in 2020 she removed the plasma (the part of the blood without cells) of old animals and replaced it with a neutral mixture of albumin and salt water. This was like pressing the Delete key on the swarm of hormones,

In this tutorial, we use Anthropic’s claude-protein-binder-design dataset, which contains 1,440 AI-designed miniprotein binders tested against 16 targets. Because the release includes both computational predictions and real wet-lab results from two independent labs, we can go beyond simply studying the designs. We evaluate how well structure predictors identify successful binders, whether combining predictions improves performance, how rankings translate into practical testing budgets, and how much disagreement comes from the assays themselves. Also, we train a target-aware classifier to test whether these signals can reliably predict experimental success. Copy CodeCopiedUse a different Browser import subprocess, sys, warnings, itertools, math warnings.filterwarnings(“ignore”) import importlib.util _needed = {“huggingface_hub”: “huggingface_hub>=0.24”, “pyarrow”: “pyarrow”, “pandas”: “pandas”, “sklearn”: “scikit-learn”, “matplotlib”: “matplotlib”, “scipy”: “scipy”} _missing = [pkg for mod, pkg in _needed.items() if importlib.util.find_spec(mod) is None] if _missing: print(“installing:”, “, “.join(_missing)) subprocess.run([sys.executable, “-m”, “pip”, “install”, “-q”, *_missing], check=False) import numpy as np import pandas as pd import matplotlib.pyplot as plt from scipy import stats from huggingface_hub import HfApi, hf_hub_download from sklearn.metrics import roc_auc_score, cohen_kappa_score, average_precision_score from sklearn.model_selection import GroupKFold, StratifiedKFold from sklearn.ensemble import HistGradientBoostingClassifier from sklearn.inspection import permutation_importance SEED = 0 rng_global = np.random.default_rng(SEED) pd.set_option(“display.width”, 200) pd.set_option(“display.max_columns”, 100) plt.rcParams.update({“figure.dpi”: 110, “font.size”: 9, “axes.grid”: True, “grid.alpha”: 0.25, “axes.spines.top”: False, “axes.spines.right”: False}) REPO = “Anthropic/claude-protein-binder-design” BAR = “=” * 78 def head(n, title): prefix = f”{n}. ” if str(n) else “” print(f”n{BAR}n {prefix}{title}n{BAR}”) head(1, “TABLE DISCOVERY”) api = HfApi() repo_files = api.list_repo_files(REPO, repo_type=”dataset”) TABLES = {} for f in repo_files: if f.startswith(“data/tables/”) and f.endswith(“.parquet”): key = f[len(“data/tables/”): -len(“.parquet”)].replace(“/”, “_”) TABLES[key] = f print(f”Found {len(TABLES)} Parquet tables:”) for k in sorted(TABLES): print(f” – {k:38s} {TABLES[k]}”) def load_table(name: str) -> pd.DataFrame: “””Load a subset by its viewer name, with a datasets-library fallback.””” if name in TABLES: return pd.read_parquet(hf_hub_download(REPO, TABLES[name], repo_type=”dataset”)) from datasets import load_dataset return load_dataset(REPO, name, split=”full”).to_pandas() ds = load_table(“design_summary”) print(f”ndesign_summary: {ds.shape[0]:,} rows x {ds.shape[1]} columns”) We start by installing only what the runtime is actually missing, then enumerate the repository once and build a {subset to path} map instead of hard-coding file locations. This matters because the naming is not uniform; the subset wetlab_summary lives at data/tables/wetlab/summary.parquet, and a guessed path would fail silently. With the map in place we pull design_summary, one row per design, 1,440 rows wide enough to carry every join we need downstream. Copy CodeCopiedUse a different Browser head(2, “SCHEMA + EVALUABLE SET”) CALLS = {“binder”, “non_binder”} tested = ds[“adaptyv_binding”].isin(CALLS) | ds[“twist_binding”].isin(CALLS) ev = ds[tested].copy() ev[“y”] = ev[“binder_final”].astype(int) print(f”All designs : {len(ds):,}”) print(f”Evaluable (>=1 vendor call): {len(ev):,}”) print(f”Confirmed binders : {int(ev[‘y’].sum()):,} ” f”({100 * ev[‘y’].mean():.1f}% base rate)”) print(f”Never measured : {len(ds) – len(ev):,}”) print(“nCategorical levels:”) for c in [“design_model”, “campaign”, “generator”, “sequence_design_method”, “vendor_agreement”]: vals = ds[c].astype(str).value_counts() print(f” {c:24s} ({len(vals)}): {‘, ‘.join(vals.index[:6])}” + (” …” if len(vals) > 6 else “”)) print(f”nTargets ({ds[‘target’].nunique()}): {‘, ‘.join(sorted(ds[‘target’].unique()))}”) print(f”Binder length: {ds.binder_length.min()}-{ds.binder_length.max()} aa ” f”(median {ds.binder_length.median():.0f})”) head(3, “HIT-RATE LANDSCAPE”) def wilson(k, n, z=1.96): if n == 0: return (np.nan, np.nan, np.nan) p = k / n d = 1 + z**2 / n c = (p + z**2 / (2 * n)) / d h = z * math.sqrt(p * (1 – p) / n + z**2 / (4 * n**2)) / d return p, max(0.0, c – h), min(1.0, c + h) def rate_table(df, by): rows = [] for key, g in df.groupby(by, dropna=False): p, lo, hi = wilson(int(g.y.sum()), len(g)) rows.append({by: key, “n”: len(g), “hits”: int(g.y.sum()), “rate”: p, “lo”: lo, “hi”: hi}) return pd.DataFrame(rows).sort_values(“rate”, ascending=False).reset_index(drop=True) for dim in [“design_model”, “campaign”, “generator”, “sequence_design_method”]: t = rate_table(ev, dim) print(f”n— hit rate by {dim} —“) print(t.to_string(index=False, formatters={“rate”: “{:.3f}”.format, “lo”: “{:.3f}”.format, “hi”: “{:.3f}”.format})) tt = rate_table(ev, “target”) fig, ax = plt.subplots(figsize=(9, 4.2)) ax.bar(tt.target, tt.rate, color=”#4C72B0″) ax.errorbar(tt.target, tt.rate, yerr=[(tt.rate – tt.lo).clip(lower=0), (tt.hi – tt.rate).clip(lower=0)], fmt=”none”, ecolor=”0.25″, capsize=3, lw=1) ax.axhline(ev.y.mean(), ls=”–“, c=”crimson”, lw=1, label=f”pooled {ev.y.mean():.2f}”) ax.set_ylabel(“experimental hit rate”); ax.set_title(“Hit rate by target (Wilson 95% CI)”) ax.tick_params(axis=”x”, rotation=55); ax.legend(); plt.tight_layout(); plt.show() print(“nRead this plot as the dominant effect size in the dataset: target choice ” “swamps generator choice. Any model comparison that does not stratify by ” “target is mostly measuring which targets that model was pointed at.”) We define the evaluable set by filtering on actual vendor calls rather than on binder_final, because that column is a bool and so records the 120 never-measured designs as False rather than missing. From there we compute hit rates by model, campaign, generator, and target, wrapping each in a Wilson interval since several subgroups sit in the small-n regime where the normal approximation misbehaves. The target plot is the one to read first: it shows antigen choice swamping every other factor we compare. Copy CodeCopiedUse a different Browser head(4, “PER-PREDICTOR DISCRIMINATIVE POWER”) PREDICTORS = sorted({c[len(“ipsae_min_”):] for c in ds.columns if c.startswith(“ipsae_min_”)}) print(f”Predictors ({len(PREDICTORS)}): {‘, ‘.join(PREDICTORS)}”) def auc_ci(y, s, n_boot=300, seed=SEED): s = np.asarray(s, dtype=float); y = np.asarray(y, dtype=int) m = ~np.isnan(s) y, s = y[m], s[m] if len(y) < 30 or len(np.unique(y)) < 2: return dict(auc=np.nan, lo=np.nan, hi=np.nan, n=len(y), ap=np.nan) base = roc_auc_score(y, s) ap = average_precision_score(y, s) rng = np.random.default_rng(seed) idx, boots = np.arange(len(y)), [] for _ in range(n_boot): b = rng.choice(idx, len(idx), replace=True) if len(np.unique(y[b])) > 1: boots.append(roc_auc_score(y[b], s[b])) lo, hi = (np.percentile(boots, [2.5, 97.5]) if boots else (np.nan, np.nan)) return dict(auc=base, lo=lo, hi=hi, n=len(y), ap=ap) rows = [] for p in PREDICTORS: for metric in [“ipsae_min”, “sc_dockq”]: col = f”{metric}_{p}” if col in ev.columns: r = auc_ci(ev.y, ev[col]) rows.append({“predictor”: p, “metric”: metric, **r}) perf = pd.DataFrame(rows) piv = perf.pivot(index=”predictor”, columns=”metric”, values=”auc”).sort_values(“ipsae_min”, ascending=False) print(“nAUC vs experimental binder_final:”) print(perf.sort_values(“auc”, ascending=False).to_string( index=False, formatters={c: “{:.3f}”.format for c in [“auc”, “lo”, “hi”, “ap”]})) fig, ax = plt.subplots(figsize=(9, 4.2)) x = np.arange(len(piv)); w = 0.38 for i, (metric, colr) in enumerate([(“ipsae_min”, “#4C72B0”), (“sc_dockq”, “#DD8452”)]): sub = perf[perf.metric == metric].set_index(“predictor”).reindex(piv.index) lo_err = (sub.auc – sub.lo).clip(lower=0).fillna(0) hi_err = (sub.hi – sub.auc).clip(lower=0).fillna(0) ax.bar(x + (i – 0.5) * w, sub.auc, w, label=metric, color=colr) ax.errorbar(x + (i – 0.5) * w, sub.auc, yerr=[lo_err, hi_err], fmt=”none”, ecolor=”0.3″, capsize=2, lw=0.9) ax.axhline(0.5, ls=”–“, c=”crimson”, lw=1) ax.set_xticks(x); ax.set_xticklabels(piv.index, rotation=45, ha=”right”) ax.set_ylabel(“AUC”); ax.set_ylim(0.35, None) ax.set_title(“In-silico score vs wet-lab binding, by structure predictor”) ax.legend(); plt.tight_layout(); plt.show() print(“Interpretation: AUCs land well above chance

Cohere has released Parse (parse-v5.0), a document parsing model aimed at high-volume enterprise ingestion. It is a 2.3B-parameter vision language model with an 8,192-token context window and a ~4.6GB footprint, built on Cohere Labs’ North-Micro-Vision-Instruct architecture. Parse takes a PDF, PPT or JPEG page as a base64-encoded data URI and returns Markdown containing text in reading order, tables rendered as HTML, lists, form key-value pairs, image descriptions and bounding box coordinates. There is no separate OCR stage in front of it. Cohere prices the Parse API at $1.50 per 1,000 pages and positions the model on price-performance rather than peak accuracy — a claim the company supports with a self-reported ParseBench score of 79.2 that, as we detail below, measures three of that benchmark’s five dimensions. Is it deployable? Yes, in production. Parse is generally available through the Cohere Parse API, Microsoft Foundry, AWS SageMaker, and single-tenant Model Vault. There is no waitlist and no research license. Which companies: Mid-market teams that already run a RAG stack can start on metered API calls with a free trial key. Large enterprises with residency or air-gap requirements go straight to Model Vault or private deployment. Seed-stage startups can use it, but the economics only start to matter above roughly 100K pages a month. Which industries: Cohere targets financial services, insurance, healthcare and life sciences, public sector, telecom, energy and manufacturing — the document-heavy verticals where scanned forms and dense tables are the norm. Applications: RAG ingestion, intelligent document processing, claims and invoice pipelines, contract and filing search, and giving document context to agents. What is Parse? Parse is a 2.3B-parameter vision language model built on Cohere Labs’ North-Micro-Vision-Instruct architecture, with an 8,192-token context window and a ~4.6GB footprint. It accepts PDF, PPT and JPEG pages as base64-encoded data URIs and returns Markdown containing document text, lists, tables rendered as HTML, bounding box coordinates and image descriptions. There is no separate OCR stage in front of it. The model recovers text and reading order, tables, lists, forms and key-value pairs, images and captions, and the locations of page boundaries and visual elements in one pass. Nine languages are listed as stable — Arabic, English, French, German, Italian, Japanese, Korean, Portuguese and Spanish — with zero-shot support elsewhere at lower accuracy. Two output modes matter in practice. The default returns a Markdown string per page. Setting output_format=”blocks” returns typed blocks, where a table block carries its HTML, its bounding box and a description. That second mode is what makes citation-level traceability possible. The Benchmark Cohere reports a ParseBench score of 79.2 for Parse, averaged across tables, content faithfulness and semantic formatting, ahead of Mistral OCR 4 (74.5), Azure Document Intelligence (74.3) and Databricks AI Parse (72.4). ParseBench is a LlamaIndex benchmark of ~2,078 human-verified enterprise pages scored on five dimensions: tables, charts, content faithfulness, semantic formatting and visual grounding. Cohere’s figure averages three of them and drops charts and visual grounding — the two dimensions where most parsers collapse. Against the public leaderboard, the same vendors score far lower on the full five-dimension overall: Mistral OCR 4 at 60.68, Databricks AI Parse at 60.68, Azure Document Intelligence (Layout) at 59.64. Azure’s three-dimension average works out to 74.3, which matches Cohere’s figure exactly and confirms the methodology. Cohere Parse is not currently listed on that leaderboard, where LlamaParse Agentic leads at 84.88. So 79.2 is a vendor-reported subset score, not a leaderboard position. It is a reasonable claim to test on your own documents. What it Costs Cohere prices the Parse API at $1.50 per 1,000 pages. On Model Vault, Parse 5 runs $4.00/hour or $2,500/month for a Medium instance, and $7.00/hour or $4,300/month for XL. The crossover nobody publishes: at $0.0015 per page, a single Medium instance breaks even at roughly 1.67M pages per month, and XL at roughly 2.87M. Below that, metered API calls are cheaper. Above it, dedicated capacity wins on price alone — before any argument about data residency, which is usually the real reason enterprises move to Vault. Key Takeaways Cohere shipped parse-v5.0, a 2.3B VLM that converts PDFs, slides and images into Markdown with HTML tables and bounding boxes. API pricing is $1.50 per 1,000 pages; Model Vault runs $2,500/month (Medium) or $4,300/month (XL). Dedicated capacity only beats metered pricing above roughly 1.67M pages per month. The 79.2 ParseBench figure is vendor-reported across three of five dimensions and omits charts and visual grounding. Check out the Technical details here and Try it on HF. 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 Cohere Releases Parse 5 (parse-v5.0): A 2.3B Vision Language Model That Turns Enterprise Documents Into Markdown appeared first on MarkTechPost.

I read every major model release. Most of them ship a coding number. The number goes up. The conclusion everyone draws is that junior engineers are finished. I think that conclusion is being reached the wrong way. People are reasoning from a benchmark score to a labor market outcome, skipping every step in between. So let me do it differently. Instead of asking “will agents replace juniors,” I want to ask what would have to be true for that to happen. Then check each condition against the best evidence available. There are four. Three of them are not met. The fourth is the one that should worry you, because it does not require the other three. Condition 1: Agents have to be reliable at the length of task a junior actually gets The best measurement we have here is METR’s time-horizon work. They time human experts on real software tasks, then find the task length at which a model succeeds 50% of the time. The main result is that this horizon doubled roughly every seven months from 2019 to 2025. METR’s updated Time Horizon 1.1 expanded the task suite by 34% and doubled the count of tasks running eight hours or longer. Independent readings of the 2024 to 2026 window suggest the doubling has since accelerated. The live leaderboard now puts frontier horizons in the hours. That sounds decisive. Read the methodology and it stops being decisive. Two things are important: First, 50% is not a bar you can staff against. Kwa et al. also report an 80% horizon, and at any given moment it is dramatically shorter than the 50% figure. In their data, frontier systems are near-perfect on tasks a human finishes in under four minutes and succeed less than 10% of the time on tasks that take a human more than four hours. Second, and this is the part almost nobody quotes: METR says its tasks are deliberately self-contained and well-specified. Their own framing is that a two-hour task should be read as what someone with no prior context could do in two hours, not what an experienced engineer familiar with the codebase could do. That is precisely the wrong shape. A junior engineer’s first six months are almost entirely context acquisition. Which service owns this. Why that abstraction exists. Who to ask. The benchmark measures the one part of the job that has been stripped of the thing that makes it hard. Condition 2: The benchmark has to measure the job In February 2026, OpenAI stopped reporting SWE-bench Verified and recommended others do the same. Their reasoning is worth reading in full, but two findings stand out. They audited a 27.6% subset of the dataset and found that at least 59.4% of the audited problems had flawed test cases that reject functionally correct solutions. And they found contamination: frontier models could reproduce exact gold patches and verbatim problem details, indicating training exposure. State of the art had moved from 74.9% to 80.9% over six months. The question OpenAI asked was whether the remaining failures reflected model limits or dataset properties. The answer was mostly dataset properties. Move to a harder, less contaminated set and scores fall off a cliff. SWE-bench Pro was built for exactly this, and frontier performance on it sits far below the Verified figures the launch posts advertise. Newer suites like Terminal-Bench and long-horizon evolution benchmarks are being built for the same reason. I want to be careful here. This is not “benchmarks are useless.” It is narrower and more damaging: the specific number that has been used for two years to argue juniors are obsolete was retired by the lab that created it, for reasons that make the number look better than reality. Condition 3: The cost of verifying agent output has to fall below the cost of delegating to a person This is the condition I think gets ignored most, and it is the one with the cleanest experimental evidence. METR ran a randomized controlled trial with 16 experienced open-source developers across 246 real tasks in their own repositories. AI allowed or disallowed at random. Screen recordings. Real work. Developers forecast a 24% speedup. Afterwards they estimated they had been 20% faster. They were 19% slower. Two caveats, because I would rather you trust the rest of this piece. The tools were early-2025. The sample is small and specific: experienced developers on mature codebases they know well. This is not a universal productivity estimate and METR does not claim it is. But the perception gap is the durable finding. People were wrong about the direction of their own productivity, under measurement. The wider data points the same way. Stack Overflow’s 2025 survey of more than 49,000 developers found 84% using or planning to use AI tools, while 46% actively distrust the accuracy of the output against 33% who trust it. Only 3% report high trust. Among experienced developers, high distrust runs at 20%. Google’s DORA research surveyed around 5,000 professionals and found 90% using AI at work and over 80% believing it lifted their productivity, while 30% report little or no trust in AI-generated code. DORA’s throughput finding improved from the prior year. Delivery instability did not. Their conclusion is that AI is an amplifier: it magnifies what the organization already is. Put it together. Generation got cheap. Verification did not. Review capacity is now the constraint, and review capacity is senior engineer time. Condition 4: Firms have to be willing to break their own senior pipeline Here is the uncomfortable part. Conditions 1 through 3 describe whether the substitution works. Condition 4 describes whether firms will attempt it anyway. They are not the same question, and the second one is already answered. Stanford’s Digital Economy Lab tracks ADP payroll data covering roughly one in six American workers. Their Canaries work finds that employment for 22 to 25 year olds in the most AI-exposed occupations, software development among them, has diverged sharply from older workers in the same occupations. The

The models responsible for last month’s agent hack of Hugging Face had been inadvertently trained to cheat and to communicate with each other, according to an OpenAI technical report released today. The hack, which a group of agents undertook to find solutions for a cybersecurity test that they were stuck on, has confirmed some experts’ fears that AI models might take actions that defy human desires and expectations.  Since the hack, OpenAI employees—as well as researchers at the AI evaluation nonprofit METR, which released its own report on the hack today—have worked to understand what went wrong and how similar missteps might be prevented in the future. OpenAI has already put some preventative measures in place based on what they discovered. But making sure AI models do what we want them to do, or “alignment,” remains a gnarly problem, and some of the root causes of the hack will take much longer than a month to resolve. “It’s not something you can solve overnight,” says Kai Chen, who runs OpenAI’s alignment research team. “There are challenges we’ve been tracking for a very long time, and we’re now seeing them with much greater precision.” The Hugging Face hack was a product of months of misbehavior from OpenAI agents, first as they were being trained and then as their abilities were being evaluated. This May, agents in training figured out how to use OpenAI’s infrastructure to communicate with one another and get support with difficult training tasks, including some that were impossible to solve without hacking or otherwise misbehaving. That “message board” was shut down. Then in July, while being evaluated for their cybersecurity abilities, some models created a new message board. They were supposed to be isolated from the internet, but by working together they managed to get online, hack Hugging Face, and obtain solutions for the cybersecurity problems that had stumped them. Based on their investigation, OpenAI researchers believe that events during the training phase led directly to the hack. “For almost every behavior that was worrisome at evaluation time, [we were able to] find some sort of associated behavior at training time that actually we think might have contributed to it,” says Eric Wallace, a member of OpenAI’s alignment research team.  When models correctly solve problems during training, the behaviors that led them to that solution are reinforced, and they become more likely to engage in them in the future. So if a model completed a task in May after using the original message board, it became more likely to participate in a new message board later on. This phenomenon, where AI agents misbehave in ways that are reinforced during the training process, is known as reward hacking. Reward hacking also helps to explain why the models worked so hard to make their way onto the internet. During its investigation of the incident, the OpenAI team found that, over the course of training, the models became more and more likely to probe their digital environment for weaknesses and use the tools at their disposal in unexpected ways—a sign that these behaviors were being gradually reinforced. By the time the models were facing tricky cybersecurity problems, they had learned that hacking was an effective way to achieve their goals. These results suggest that the Hugging Face hack could have been avoided if the models weren’t rewarded for misbehaving during training. While researchers don’t yet know how to prevent reward hacking entirely, OpenAI is taking some steps toward mitigating its effects. The company will now look for signs of cheating in all frontier models during training by keeping an eye on their chains of thought—internal notepads where they sketch out their answers and plan their actions.  This solution isn’t as much of a slam dunk as it might seem: In earlier research, OpenAI showed that punishing models that mention cheating in their chains of thought teaches them to keep their intentions hidden from researchers. But monitoring its models’ thinking does give OpenAI the chance to halt the training process and reassess its approach if models do start learning to reward hack. If OpenAI stops reinforcing reward hacking in its models—and that’s a huge “if”—that would be a huge step forward. But it wouldn’t solve the alignment problem. The first time a model communicated with other agents or hacked its infrastructure during training, those behaviors had never been reinforced, so agent misbehavior can’t only be attributed to that reinforcement. Jeffrey Ladish, director of the AI safety nonprofit Palisade Research, compares the agents to a human who commits their first financial crime. “It’s not like they had to do fraud before to figure out that fraud is an effective strategy, and you have the same problem with models,” Ladish says. “Alignment science needs to be understanding how model motivations get shaped, such that we can actually figure out how to get models to care about the consequences of their actions.” OpenAI’s researchers do have a hypothesis for where some of the misbehavior originated. Before the models formed their first secret message board, they had been trained to communicate and coordinate with subagents—less powerful agents to whom a main agent can delegate tasks.  That learned communication behavior could have transferred to this new setting. The METR report, which investigates the messages that the models sent to one another in detail, supports this hypothesis: One agent on the message board took charge and assigned tasks to the other agents, effectively treating them as subagents. OpenAI could try to prevent agents from secretly communicating with one another by not training this subagent behavior in the future, but that would make the models less useful.  This tension between capability and safety is at the heart of what went wrong with the Hugging Face incident. OpenAI researchers also identified the models’ persistence as a key factor in the hack.  When they were accidentally given unsolvable problems, the models didn’t give up; instead, they strove to find solutions by any means necessary. But persistence is also a virtue,

Z.ai has released GLM-5.3-Flash, the first natively multimodal model in the GLM-5 series and the cheapest capable coding model the lab has shipped. It is a mixture-of-experts model with 320B total parameters and 18B active per token, a 1,048,576-token context window, and image and video input — released under an MIT license with weights on Hugging Face. According to Z.ai reports, it beats GLM-5.2 across benchmarks and real workloads at roughly one-tenth the price, while landing within half a point of Claude Opus 4.8 on its internal coding benchmark. The model spent its first week running anonymously as “Ox Alpha” on OpenCode and OpenRouter, served entirely on domestically produced Chinese AI chips. Is it deployable? Yes, on two tracks. The weights are live on Hugging Face under an MIT license, and a hosted API is already priced and serving. Which companies can realistically self-host? Not everyone. The default FP8 checkpoint is roughly 306 GiB of weights before KV cache, and the current vLLM path supports NVIDIA Hopper and newer only. That puts self-hosting in reach of mid-size and large orgs with at least an 8-GPU node (or a GB200 tray at TP4), plus AI-native startups renting GPU capacity. Everyone below that line consumes it as an API — where the economics, not the hardware, are the story. Industries with immediate fit: software and devtools, IT/BPO automation, financial services and insurance document operations, enterprise BI and back-office knowledge work, e-commerce and any team shipping UI at volume. Applications: repo-scale coding agents, terminal and browser/computer-use agents, million-token log and contract analysis, UI regression checking from screenshots, and spreadsheet/deck/dashboard reasoning that would otherwise need an OCR-to-text pipeline. The architecture is where the efficiency comes from GLM-5.3-Flash starts from a newly trained base model on a 30T-token multimodal corpus. Three changes are worth knowing: Hybrid attention: For the first time in the GLM series, Z.ai combines linear and sparse attention. Per the vLLM recipe, the 45-layer language model interleaves KDA linear-attention layers with NoPE sparse MLA layers, routes each token through 8 of 288 experts, and ships native FP8 weights plus one MTP draft layer. Linear attention handles local dependency; sparse attention retrieves the globally relevant context. IndexPool: At million-token context, retrieval itself becomes the bottleneck. IndexPool compresses groups of indexer key vectors through weighted pooling to hold down latency and memory. Z.ai reports ~3× less attention compute and a 4.4× smaller KV cache versus GLM-5.3. mHC: The model adopts Manifold-Constrained Hyper-Connections to improve scaling efficiency. Against GLM-4.5, at similar total parameter count, GLM-5.3-Flash roughly halves both activated parameters and layer count. Benchmarks Most numbers mentioned in the table below are Z.ai-reported and the harnesses differ per test — the model card’s footnotes specify temperature, context limits and judge models per benchmark, so treat cross-model comparisons as setup-dependent. Benchmark GLM-5.3-Flash Reference Terminal-Bench 2.1 84.3 Opus 4.8: 85.0 · GPT-5.6 Terra: 87.4 DeepSWE v1.1 63.4 GLM-5.2: 46.2 AutomationBench 48.8 GLM-5.2: 26.2 HLE 55.3 — OfficeQA Pro 62.4 ahead of Opus 4.8 Z.ai Code Bench v1.0 (max) 29.0 Opus 4.8: 29.5 Independently, Artificial Analysis scores it 57 on the Intelligence Index, with 48.7 output tokens/sec and 1.52s TTFT on Z.ai’s API — strong intelligence-per-dollar, but slow and verbose. Vision is the weak flank: it trails Gemini 3.7 Flash on BabyVision and MVbench. The serving story is the underreported part Z.ai states the entire Ox Alpha preview ran on domestically produced Chinese AI chips, using a custom SGLang-based engine that disaggregates encoding, prefill and decoding, and reports a 3× end-to-end serving improvement across tens of thousands of accelerators. Pricing and access Standard API pricing is $0.15/M input, $0.03/M cached input, $0.50/M output. Z.ai reports a score of 57 on Artificial Analysis Intelligence Index v4.1.1 at $0.045 per task on the discounted tier. The model is live for all GLM Coding Plan tiers — Lite ($18/mo), Pro ($80), Max ($168) — at 3× the usable quota of GLM-5.3, and its multimodal capabilities surface in ZCode through Browser Use and Computer Use. Local serving is supported on SGLang, vLLM, TokenSpeed and KTransformers. Key Takeaways 320B-A18B natively multimodal MoE, 1M context, MIT-licensed weights on Hugging Face. Hybrid KDA linear + NoPE sparse MLA attention: ~3× less attention compute, 4.4× smaller KV cache. 84.3 Terminal-Bench 2.1 and 63.4 DeepSWE v1.1 — near Opus 4.8, well past GLM-5.2. $0.15/$0.50 per M tokens; 3× GLM-5.3 quota for every GLM Coding Plan tier. Self-hosting needs ~306 GiB FP8 weights on Hopper-or-newer; everyone else uses the API. Check out the Model Weights and Blog. 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 Z.ai Releases GLM-5.3-Flash: A 320B-A18B Natively Multimodal MoE With a 1M-Token Context appeared first on MarkTechPost.