TAI #212: AI Engineer World's Fair: Agent Loops and Forward-Deployed Engineers

Also, OpenAI's Alexander Embiricos on Codex and enterprise deployment, Claude Fable 5 returns, GPT-5.6 goes public Thursday & more.

Louie Peters, Towards AI, and Louis-François Bouchard

Jul 09, 2026

What happened this week in AI by Louie

OpenAI confirmed that GPT-5.6 Sol, Terra, and Luna will go public on Thursday, following a phased rollout with approved partners. Claude Fable 5 returned on July 1 after its government-enforced shutdown, with a brief promotional allowance within paid subscriptions before usage moves to a credit system. Access to the strongest models is widening again. At the AI Engineer World’s Fair in San Francisco, attention had already shifted one layer downstream: the agent loops that keep those models working and the forward-deployed engineers who fit them to real companies.

Five of the Towards AI team attended, and three, Louis-François Bouchard, Samridhi Vaid, and Omar Solano, delivered a two-hour workshop on “Context Engineering in 2026: Compaction, Memory & Cost.” The wider event ran more than 500 sessions across 29 tracks, with around 300 speakers and over 6,000 attendees. Of 561 session titles in the final open schedule data, 236 included “agent” or “agentic,” 18 included “harness,” and a dedicated Forward Deployed Engineering track ran nine sessions.

Two ideas kept coming up. An agent loop starts with a goal and repeats until it reaches an acceptable result, hits a budget, or needs human intervention. A simple loop inspects context, chooses an action, uses a tool, evaluates the result, and updates its state. More capable loops delegate to subagents, preserve memory, run evaluations, compare alternatives, and rewrite the prompt, skill, code, or artifact that guides the next attempt. The LLM can generate its own next instruction from the goal and feedback, test whether the change improved the measured outcome, and keep iterating. The human still defines the top-level objective, constraints, permissions, evaluation signal, and stop condition. This optimizes the work process at inference time; the model is not retraining its own weights.

A forward-deployed engineer, or FDE, makes that loop useful inside an organization: identifying the workflow, connecting the systems, defining permissions, creating evaluations, earning support from the people doing the work, and improving the deployment over time.

The loop takes two forms. It can help someone complete their existing day job faster inside tools such as Codex or Claude Code, with the person directing the work. It can also be embedded in an external product or an internal tool, where model calls, retrieval, memory, permissions, and evaluations serve as the AI layer behind a custom workflow. An FDE needs to understand both how people work effectively with agents and how to turn those techniques into reliable software.

This distinction shapes how we train experienced software engineers to become AI engineers and FDEs at Towards AI. Agentic coding is often the best on-ramp. They watch an agent plan, use tools, lose context, recover, test its output, and fail in recognizable ways, which teaches them where the models reach their limits. From there, they move on to retrieval-augmented generation (RAG), API-based agents, fine-tuning, and evaluation, and then build similar decision-making loops into external products.

Immediately after his opening keynote, I interviewed Alexander Embiricos, OpenAI’s Head of Enterprise Product, with Romain Huet, OpenAI’s Head of Developer Experience, joining partway through. We covered Codex, enterprise agents, process mining, FDEs, evaluation, token economics, and where OpenAI sees the most demand for agent work.

Alex’s account of OpenAI’s own deployment work shows how quickly the technical layer has simplified.

Two or three years ago, its FDE team built custom agent harnesses and kept adding pieces for each customer. This meant deliveries took 6 to 9 months and much longer to scale to new customer teams. Codex eventually became a shared base. “Late last year, the FDE team realized they should throw away much of their custom code and retrain the team to build with Codex as the core harness,” Alex told me. “The core agent loop is genuinely simple, and we keep all the abstractions at arm’s length.”

That simplicity improves handover. A customer can change an agent’s instructions or skills without asking the original engineering team to rewrite the system. Conventional software still handles the steps where variation creates risk. “If you can use an agent, it’s much easier to hand off to the customer, because they can just prompt the agent to do something differently,” Alex said. “And where you need determinism, you can put a script in a plugin.”

Internal web apps are a natural output from these loops. Codex Sites lets eligible Business and Enterprise workspaces ask Codex to build, deploy, and share internal applications with role-based access controls. “The idea is to close that loop: an agent collects a bunch of info, writes some code, and you deploy that code to your team,” Alex said.

We discussed the dashboards Towards AI builds for investors and companies. The hard part is helping an agent understand messy data, business definitions, permissions, and the decisions the interface needs to support. Once that foundation is in place, the customer should be able to change the dashboard via the agent. Alex described his ideal: “You have a Teams or Slack channel with an agent living in it that owns a dashboard.” The agent answers questions, updates the underlying analysis, and adds a requested chart or metric. He expects internal tools to reach meaningful autonomy first. “Having agents deploy to prod autonomously is the holy grail,” he said. “For a hedge fund, that’ll take a very long time. But having agents deploy to prod autonomously for an internal dashboard, that’s where I think we start seeing these experiences first.”

That is a sensible boundary. An internal dashboard is constrained, visible, and easy to roll back; a trading, payment, or customer system carries a much larger blast radius.

The people layer was just as prominent at the World’s Fair. The FDE track included sessions from Factory, Cursor, Cognition, Decagon, Ramp, and Kepler. OpenAI launched its Deployment Company in May with approximately 150 Forward Deployed Engineers and Deployment Specialists, seeded by Tomoro, while keeping another FDE group inside OpenAI. OpenAI’s internal FDEs focus on partnering with research and product to explore and shape next-gen offerings. Meanwhile, the Deployment Company operates like an AI-native services business, helping a wide range of companies build and deploy AI systems at scale.

Romain gave the clearest explanation for why the role is difficult. “The easiest part is the AI pieces,” he said. “The hardest and longest-running thing to figure out is the non-AI pieces: access controls, permissions, the read and write rules for the agents, and who the stakeholders are that need to be bought in at every step. That’s the hard part FDEs navigate.”

Alex set a high technical bar: “An FDE at OpenAI could be a software engineer at OpenAI.” The same person also needs to “do the management-consultant part: go talk to the customer, find their use cases, define them together.” The combination is rare. Strong software engineers can struggle to identify the workflow that truly matters to the client; strong consultants can struggle to build and debug a production agent. The best FDEs hold both skill sets plus enough humility to learn the customer’s domain.

Alex asked how this connects to Towards AI. I left J.P. Morgan in 2018, and we started Towards AI in 2019 as a publication, community, and education platform, later building practical courses that turn experienced software developers into AI engineers, with production systems as the standard. That work pulled us into deployment. We start by asking whether existing products, skills, and training can solve the problem, then build custom systems when proprietary data, integrations, evaluations, access controls, or workflow exceptions demand it. Around 15 people now work on our deployments, pairing AI engineers from our community with domain specialists who combine private-equity or investment experience with strong technical backgrounds. The pairing mirrors Alex’s FDE definition: discover the use case, understand its economics, build the system, and stay close enough to the client to make it work.

Process mining may help this work scale. OpenAI has built a recorder that lets a user show an agent how to perform a task. Alex’s longer-term version continuously observes work and identifies automation opportunities. “Your agent wakes up every morning and says: I noticed these processes we could automate. Here’s what it’ll cost, here’s what I think it’ll save, is it worth it?” he said.

That creates a higher-order agent loop for AI adoption itself. Give the system a goal, such as reducing handling time without weakening controls, and it can observe work, propose an automation, estimate the value, ask for approval, measure the result, and revise the workflow or its own instructions based on the observed gap. The FDE defines the goal, evidence, permissions, and escalation path around it. AI deployment becomes a continuous operating process instead of a sequence of disconnected pilots.

Alex described a similar loop for cost and utility. Skills and connectors provide anchor points for classifying work, and usage data shows which models people choose, where an instruction creates confusion, and which agents and workflows lead to action. “Every IT admin, CIO, or CFO I talk to has this idea of ‘what if it just got cheaper over time and self-optimized?’” he said. His shorthand for the result: “The IT admin basically becomes Iron Man, optimizing the whole company.”

That puts Alex’s cost claim in sharper focus. “Even our current models are significantly more token-efficient than the others out there, and our new ones are insanely efficient,” he said. “If you want to get much more done per dollar, come to us.” GPT-5.6 will need independent testing after Thursday, but Sonnet 5 already shows why completed work per dollar matters more than a model’s tier or list price. Artificial Analysis measured 300 million output tokens across its Intelligence Index for Sonnet 5 at max effort, compared to 120 million for Opus 4.8, and Sonnet 5 ran around three times as many turns as Sonnet 4.6 in its agentic knowledge-work evaluations. At the standard $3 per million input tokens and $15 per million output that begins in September, that works out to $2.29 per weighted Intelligence Index task, around 15% above Opus 4.8. Anthropic’s temporary launch pricing softens the current bill, but adaptive thinking is enabled by default, and the new tokenizer produces around 30% more tokens for the same text than Sonnet 4.6 does.

We will not use Sonnet 5 in Towards AI deployments for now: the published evidence does not demonstrate sufficient incremental value to justify the additional test-time compute. A model can be capable and still be a poor economic choice once its reasoning and agent turns multiply across a long production loop.

Any spend-optimization loop starts with transparency. Executives often see a maximum cost per user without knowing what the AI did. “The problem right now is that people have no visibility into what the model is being used for,” Alex said. An agent can turn token and tool traces into an operating account: average cost per person, which tasks absorb the most compute, how many analyses lead to action, where a cheaper model works, and which skills need clearer instructions. “The best products we build are obvious and simple, and the AI does the hard part,” he said.

The outcome-first approach also shapes evaluation. “Benchmarks are lagging indicators of what we’re trying to accomplish,” Alex told me. Product teams start with a user outcome and a rough private evaluation, then formalize it if the capability becomes important. Public benchmarks also lose reliability once their tasks are included in the training data; Alex compared contamination to “being given the exam before you take it.” Real company tasks, private evaluation sets, and production traces will carry more weight as public scores cluster near the top.

The compute demand could be enormous. Coding and research already split large goals into parallel tasks and keep spending tokens, while each extra attempt remains useful. Alex named data science as OpenAI’s most token-hungry non-research function. “Data analytics, whatever you call it, is super token-hungry and super high-ROI,” he said. He also sees digital operations, accounting, finance, and regulatory compliance as strong areas for automation. For general knowledge work, OpenAI’s position is that “it shouldn’t feel like automation; it should feel like teammates.”

Our World’s Fair workshop focused on the engineering discipline beneath that vision. Long-running agents forget constraints, accumulate tool output, compact imperfectly, retrieve the wrong context, and preserve bad assumptions in memory. Teams need to measure full trajectories: tokens, cost, cache hits, latency, retrieval quality, memory performance, retries, and human rescue. A stronger model helps; a well-engineered loop makes the gains repeatable.

Why should you care?

The sequence to act on is simple: learn how agents fail on work you can judge, prove a controlled loop on one bounded workflow, then make what works repeatable.

Start with a codebase, dataset, or work product you know well. Record where the agent loses context, takes a plausible wrong turn, or fails a test. That failure log is your first evaluation set, and it tells you which parts of a real workflow need retrieval, deterministic code, or human review. The same method carries into finance, law, operations, and compliance; every field needs people who can turn domain knowledge into goals, permissions, and evaluations.

Inside a company, the step is organizational. Read access first; permissions expanded one reversible workflow at a time; a named business owner and technical owner; and an FDE close to the team whose work is changing. The exceptions that a person uncovers become tools, evaluations, and escalation paths.

Every deployment should leave two things behind: a reusable asset, such as an evaluation set, permission pattern, or cost baseline, and a team trained to keep working with AI after the engineers move on.

— Louie Peters — Towards AI Co-founder and CEO

Hottest News

1. Anthropic Redeployed Fable 5

Anthropic restored global access to Claude Fable 5 on July 1, 19 days after the US Commerce Department issued an export-control directive that required the company to disable the model for all users. The directive was triggered after Amazon researchers found a method to bypass Fable 5’s safeguards, prompting it to identify software vulnerabilities and, in one case, to produce exploit code. Anthropic’s testing confirmed that less capable models, including Claude Opus 4.8, GPT-5.5, and Kimi K2.7, could identify the same vulnerabilities, and that every tested model reproduced the single exploit demonstration. To redeploy, Anthropic added a new classifier that blocks the reported technique in over 99% of cases, with flagged requests rerouted to Opus 4.8. The Commerce Department’s AI standards body (CAISI) tested the safeguards and called them “extraordinarily strong.” In the near term, some routine coding and debugging tasks will fall back to Opus 4.8 due to false positives, which Anthropic says it will refine over the coming weeks. Access is metered: Fable 5 is included for up to 50% of weekly usage limits through July 7 for Pro, Max, Team, and select Enterprise plans, after which it requires usage credits. Mythos 5 remains restricted to approved US organizations. Anthropic is also drafting a consensus framework with Amazon, Microsoft, Google, and other Glasswing partners for scoring jailbreak severity across the industry.

2. Claude Sonnet 5 Launched as Anthropic’s Most Agentic Mid-Tier Model

Anthropic released Claude Sonnet 5, a model built to narrow the gap between the Sonnet and Opus tiers on agentic performance. Sonnet 5 delivers performance close to Opus 4.8 in coding, tool use, reasoning, and knowledge work, but at a lower price. It is available across all plans: the default model for Free and Pro, and available to Max, Team, and Enterprise users. Introductory API pricing is $2/$10 per million input/output tokens through August 31, rising to $3/$15 after that. Anthropic reports that Sonnet 5 is a strict improvement over Sonnet 4.6 across all tested effort levels and, at higher effort, can match Opus 4.8 on some tasks. Safety evaluations found lower rates of hallucination, sycophancy, and overall misaligned behavior compared to Sonnet 4.6, though somewhat higher rates than Opus 4.8 and Mythos Preview. Sonnet 5 was not deliberately trained on cybersecurity tasks and shows substantially lower cyber capabilities than current Opus models, but it launches with the same cyber safeguards as Opus 4.7 and 4.8, enabled by default. The tokenizer has changed: the same input can map to 1.0–1.35x more tokens, but Anthropic says the introductory pricing is set to make the transition roughly cost-neutral.

3. OpenAI Proposed Giving the US Government a 5% Ownership Stake

OpenAI has proposed handing the US government a 5% equity stake in the company, worth approximately $42.6 billion at its $852 billion March 2026 valuation, according to the Financial Times. CEO Sam Altman argued that giving the public a financial interest is the best way to share the upside of AI. The proposed arrangement envisions other US AI companies, including Anthropic, Google, and Meta, ceding similar stakes to the government through a sovereign wealth fund vehicle modeled on Alaska’s Permanent Fund. It is not clear whether any of these companies would agree. An Anthropic source told CNBC that the Trump administration and Anthropic have not discussed the government taking a stake in the company. Altman first pitched the concept to the Trump administration in early 2025, and OpenAI published a white paper in April 2026 proposing a “Public Wealth Fund” to hold equity in AI companies and distribute economic benefits to the public. The US government has a precedent for taking equity stakes in tech companies, including a 10% stake in Intel and revenue-sharing arrangements with NVIDIA and AMD for AI chip sales to China. The proposal remains in early-stage discussions and would likely require congressional approval.

4. Mistral AI Released Leanstral 1.5

Mistral AI released Leanstral 1.5, a 119B-parameter sparse MoE model with 6B active parameters, built for formal mathematical proof engineering in Lean 4. The model saturates miniF2F completely (100% on both validation and test sets), solves 587 out of 672 PutnamBench problems, and achieves a new state-of-the-art of 87% on FATE-H and 34% on FATE-X for graduate- and PhD-level abstract algebra. On PutnamBench, it edges out Seed-Prover 1.5 by 7 problems at roughly $4 per problem versus an estimated $300+ for Seed-Prover. Training follows a three-stage process: mid-training, supervised fine-tuning, and reinforcement learning with CISPO across two environments, a multiturn proof loop with compiler feedback, and a code agent environment where the model edits files, runs bash commands, and uses the Lean language server. Beyond mathematical benchmarks, Leanstral 1.5 discovered 5 previously unreported bugs across 57 open-source repositories by automatically generating correctness properties from Rust code translated to Lean. The model is released under the Apache 2.0 license on Hugging Face, with a free API endpoint.

5. Anthropic Announced Claude Science

Anthropic launched Claude Science, an AI workbench that brings fragmented scientific tools into a single research environment. Scientists interact with a generalist coordinating agent that provides access to over 60 curated skills and connectors preconfigured for genomics, single-cell analysis, proteomics, structural biology, and cheminformatics. The agent can spin up specialist sub-agents and a reviewer agent that checks citations, calculations, and figure-code consistency, flagging and correcting errors as work progresses. Claude Science natively renders 3D protein structures, genome browser tracks, chemical structures, and other scientific visualizations alongside the code that produced them, with a full auditable history for reproducibility. It runs on researchers’ own infrastructure (laptop, Linux box, or HPC login node via SSH), so datasets stay local, and it can scale to cloud GPUs via Modal for larger analyses. Claude Science integrates with NVIDIA’s BioNeMo Agent Toolkit to provide access to models such as Evo 2, Boltz-2, and OpenFold3. Anthropic is supporting up to 50 AI for Science projects with up to $30,000 in credits, with applications open through July 15. Available in beta for Pro, Max, Team, and Enterprise plans on macOS and Linux.

6. NVIDIA AI Introduced ASPIRE

NVIDIA published ASPIRE (Agentic Skill Programming through Iterative Robot Exploration), a continual learning system for robotics that autonomously discovers reusable skills by writing, executing, and iteratively refining code-as-policy robot control programs. The system operates in an open-ended learning loop with three components: a closed-loop robot execution engine that records fine-grained multimodal traces of each perception, planning, and control call; a continually expanding skill library that distills validated fixes into transferable knowledge; and an evolutionary search procedure that generates diverse task sequences and control programs. ASPIRE uses Claude Opus 4.6 as its frontier reasoning model. Across LIBERO-Pro, Robosuite, and BEHAVIOR-1K benchmarks, ASPIRE substantially outperforms existing VLA and coding-agent baselines. Skills discovered in simulation transfer zero-shot to unseen long-horizon tasks and across embodiments to real robots, reducing real-robot programming token cost while achieving higher success rates. The authors note that the system is not yet a fully autonomous real-world learner and relies on a frozen-frontier LLM.

Five 5-minute reads/videos to keep you learning

1. Building a Conversational Flight Booking Assistant from Scratch with LangGraph, OpenAI API, and Telegram

The piece walks through a LangGraph- and OpenAI-powered IndiGo-style bot spanning Streamlit and Telegram, covering synthetic database generation, a categorized state schema, and three prompt families that split extraction, classification, and conversation. It uses state-driven routing to skip redundant LLM calls after the first turn and pure Python for validation, retries, and city resolution. It offers a practical blueprint for task-oriented dialogue systems that extends well beyond airline bookings.

2. Fine-Tune Your First LLM: A Guide with PyTorch and Hugging Face

This article covers the full supervised fine-tuning of the Gemma 3 270M model with PyTorch, Hugging Face, and TRL. It walks through training the model on the FoodExtract-1k dataset to convert raw text into structured food and drink extractions, covering hardware checks, dataset formatting, SFTConfig hyperparameters, and evaluation via manual inspection and token-level accuracy. It also shows how to save the model locally and publish it to Hugging Face Hub with a complete model card.

3. MCP Explained: The Standard That’s Quietly Changing How AI Agents Work

MCP emerged as Anthropic’s answer to the N×M integration mess, and OpenAI and Google DeepMind adopted it within months. The piece breaks down its three components: host, client, and server, and the three primitives servers expose: tools, resources, and prompts. It walks through a working Python server example and the underlying JSON-RPC wire format. It also covers tool poisoning, rug pull attacks, and real incidents like the mcp-remote CVE.

4. Building Production-Ready Agentic AI Systems with Docker and FastAPI

The piece walks through containerization strategies, async orchestration patterns, and security layers that keep autonomous agents compliant and auditable. It covers fraud detection and flight delay management, using code examples to show how agents gather data, reason across parallel tool calls, and execute coordinated actions. It also explains caching, cost optimization, and observability as a complete blueprint for scaling agentic infrastructure without sacrificing reliability.

5. Prefill/Decode Disaggregation: Why Your GPU Can’t Do Two Things at Once

Prefill and decode are fundamentally different workloads competing for the same GPU. Prefill runs compute-heavy batch processing over an entire prompt, favoring tensor parallelism, while decode generates tokens one at a time and stays memory-bound, starved by weight loading from HBM. The piece traces how tensor, pipeline, and data parallelism each optimize one phase at the expense of the others, then explains disaggregation: separate GPU pools connected via KV cache transfers, plus techniques such as overlapping transfers and INT8 compression to mitigate latency.

Repositories & Tools

1. Strix are autonomous AI penetration testing agents that act as real hackers to find vulnerabilities in your code and validate them through actual proofs of concept.

2. System Prompts Leaks is a collection of extracted system prompts from models like Fable 5, ChatGPT 5.5 Thinking, Gemini 3.1 Pro, Grok, Cursor, Copilot, Perplexity, etc.

3. Codex-plugin-cc is OpenAI’s official plugin for running Codex inside Claude Code without leaving the Claude Code session.

4. OpenScience is a model-agnostic AI workbench for scientific research with specialist agents for biology, physics, ML, and chemistry.

Top Papers of The Week

1. Scaling the Horizon, Not the Parameters: 35B Agent Matches Trillion-Parameter Performance

This paper introduces Agents-A1, a 35B MoE model that matches trillion-parameter models on long-horizon agent benchmarks by scaling the agent horizon rather than model size. The training infrastructure produces agentic trajectories that average 45K tokens by integrating external knowledge, actions, observations, and verifier outcomes. A three-stage recipe first aligns the base model with broad agentic behaviors through supervised fine-tuning, then trains domain-level teacher models to capture specialized expertise, and finally unifies six heterogeneous domains into a single deployable student through multi-teacher, domain-routed, on-policy distillation with salient vocabulary alignment. Compared to 1T-parameter models like Kimi-K2.6 and DeepSeek-V4-Pro, Agents-A1 leads on SEAL-0 (56.4), IFBench (80.6), HiPhO (46.4), FrontierScience-Olympiad (79.0), and MolBench-Bind (56.8) while remaining competitive on SciCode, HLE, and BrowseComp.

2. DOPD: Fixing Privilege Illusion in On-Policy Distillation

On-policy distillation (OPD) improves capacity transfer by supervising student-sampled trajectories, and a natural way to further improve quality is to give the teacher or student access to privileged information during training. This paper identifies a failure mode it calls the privilege illusion: the student conflates the transferable capability gap it is meant to close with the information asymmetry gap it can only mimic, not replicate, at deployment. DOPD addresses this with an advantage-aware dual distillation paradigm that dynamically routes token-level supervision between the privileged teacher and the privileged student based on their advantage gap and relative probabilities. Each token receives supervision of varying strength, objective, and strategy, thereby transferring credible capability while filtering out signals that rely on information the deployed model will never have.

3. Program-as-Weights: Compiling Natural Language into Compact Neural Programs

Many programming tasks resist clean rule-based implementation (alerting on important log lines, repairing malformed JSON, ranking search results by intent) and are increasingly outsourced to LLM APIs at the cost of locality, reproducibility, and price. This paper proposes fuzzy-function programming: compiling a natural-language function specification into a compact, locally executable neural artifact. Program-as-Weights (PAW) uses a 4B compiler model trained on FuzzyBench (a 10M-example dataset released with the paper) to emit parameter-efficient adapters for a frozen, lightweight interpreter. A 0.6B Qwen3 interpreter executing PAW programs matches the performance of directly prompting Qwen3–32B while using roughly one-fiftieth of the inference memory and running at 30 tokens per second on a MacBook M3.

4. Agentic Abstention: Teaching Agents When to Stop Instead of Act

Not every goal an agent receives is achievable in the available environment, but current agents rarely recognize this. This paper formalizes agentic abstention as a sequential decision problem: at each turn, the agent can answer, abstain, or gather more information, and the need to stop may only become clear after interacting with the environment. Evaluating 13 LLM-as-agent systems and 2 agent scaffolds on over 28,000 tasks across web shopping, terminal environments, and question answering, the authors find that the core challenge is not whether agents can abstain but when. Some never abstain when they should; others do so only after many unnecessary tool calls. Larger and more capable models sometimes perform worse at timely abstention. The paper introduces CONVOLVE, a context engineering method that distills full interaction trajectories into reusable stopping rules without updating model parameters.

5. Introducing TabFM: A Zero-Shot Foundation Model for Tabular Data

Google Research released TabFM, a foundation model that performs tabular classification and regression in a single forward pass on unseen tables with no dataset-specific training, hyperparameter search, or feature engineering. The model treats tabular prediction as an in-context learning problem: training rows and query rows are passed together as one prompt, and predictions are returned directly from frozen weights. TabFM was pretrained on hundreds of millions of synthetic datasets generated using structural causal models (SCMs), chosen to encode inductive biases about causal structure and feature relationships without privacy or licensing concerns. Evaluated on TabArena across 51 datasets (38 classification, 13 regression), it achieves competitive Elo scores, with a stronger 32-way ensemble variant that uses SVD features and Platt scaling.

Quick Links

1. Z.ai released ZCode, the official agentic development environment for GLM-5.2, available as a free desktop app on macOS, Windows, and Linux. ZCode puts the agent conversation at the center rather than the editor, with a file manager, terminal, Git panel, and live browser preview built around it. It supports long-running Goals that plan, execute, and verify across multi-step tasks, BYOK for third-party models, and remote control from WeChat and Feishu. GLM Coding Plan subscribers get a 1.5x quota bonus inside ZCode through July 31. Plans start at $16.20/month for Lite, $64.80 for Pro, and $144 for Max.

2. Sakana AI launched Sakana Translate, a free web app added to Sakana Chat that handles bidirectional translation across Japanese, English, and Chinese. Powered by the Namazu model series, it ships with three modes: Translate for long-form text up to 5,000 characters with streaming output, Proofread for adjusting tone, politeness, and natural expression with diff highlighting, and Ask for querying translation results for nuance, grammar, and alternative phrasing without switching tools. On WMT 2024 General Translation, evaluated with XCOMET-XL, Sakana AI reports scores comparable to leading frontier models.