AIWatch.

We’ve lost count of how many adoption milestones have been passed since the original Rise of the AI Engineer post, but surely Andrew Ng, cofounder of Google Brain and Coursera among many other things, relaunching DeepLearning.ai with a focus on AI Engineering is a big one:

This was done via “an analysis of over 10,000 job postings; carrying out dozens of structured interviews with AI experts, hiring managers, and recruiters; gathering data through surveys; and synthesizing other online data” .

Here are the four most important AI engineering skills according to Andrew:

You can read his full post for more from the horses’ mouth, but we agree that “AI Engineering Skills” are broadly applicable to more than just those with the job title of “AI Engineer” and that is an insightful focus.

Commentary on the 4 skills:

• Building and deploying AI applications: “People who are skilled at building and deploying AI applications understand the building blocks of AI (such as LLMs, context engineering, RAG, agentic workflows, machine learning and deep learning) and, importantly, how to use statistical techniques to measure, steer, and govern AI systems so that they behave more predictably. A core skill in doing so is knowing how to drive disciplined evals and error analysis loops.”yup. this part is closest to the traditional MLE/MLOps workflow, from “zero gradient” aka prompt engineering techniques, to harness engineering, to finetuning and beyond, all the way up to building your own agent lab as folks like Harvey are now doing
• Software engineering fundamentals. “Understanding software fundamentals allows you to recognize what tradeoffs even exist. This leads to better decisions in choosing your software stack, designing system architecture, designing your data store, testing, and so on. It also leads to much better outcomes than those for an inexperienced developer who vibe codes a solution without knowing the tradeoffs their coding agent is making — which will often be poor ones, because they don’t know what context to give their coding agent.”yup. this part is closest to the traditional SWE workflow. LLMs reward expertise — they raise the ceiling (high skill devs) much more than they raise the floor (low skill vibecoders), though both are improved.
• Using coding agents. “Using agentic coding effectively is now a key skill for every developer. When you have this skill, you have a good mental model for how agents work. You understand their limitations and how to work around them, and are able to quickly steer them — knowing how much to intervene and how much to leave them alone — to build robust software without wasting excessive time or tokens. You also need to know how to work with a clear spec (and when not to bother doing so), orchestrate multiple agents that work together, and avoid pitfalls like risk an agent messing up your production database. Because agentic coding is evolving quickly, using coding agents skillfully means not only knowing cutting-edge practices, but also having routines to keep trying new tools and evolve your workflows as best practices change.”When we first spoke about the 1000x AI Engineer in 2023, when Copilot was the only game in town, this was the part that was the least evident, but clearly on the horizon. Coding exploded in 2024-2026 culminating in the epic 0-$60B run of Cursor and the rise of Claude Code, Codex, Cognition, Cline and other coding powerhouses not starting with C. Being nimble here is a plus, just as much as being wary of tokenmaxxers with LLM psychosis.
• Shaping the build. “Effective AI engineering requires having product sense and understanding business context and customer goals, so you can participate in shaping and driving the build… Taking advantage of this opportunity requires knowing how to drive projects forward. For example, knowing when to quickly build an MVP to take to users for testing, and when to slow down and take longer in order to build more carefully.”This is perhaps the only part of AI Engineering that wasn’t foreseen in the original essay; we added the AI PM track in World’s Fair 2024 and soon Design Engineering and other AIE adjacencies because the lines started to blur very quickly in both directions.

Overall, a great update to the DeepLearning.AI focus. Welcome Andrew and team!

AI News for 8/22/2026-8/24/2026. We checked 12 subreddits, 544 Twitters and no further Discords. AINews’ website lets you search all past issues. As a reminder, AINews is now a section of Latent Space. You can opt in/out of email frequencies!

Agent Harnesses, Persistent Agents, and Enterprise MCP

• Harness design is becoming a primary optimization surface: Several posts converged on the idea that agent quality is increasingly shaped by the harness rather than just the base model. NVIDIA’s new evaluation work argues that structural checks on agent “skills” barely predict usefulness—scan scores correlate with judged quality at just Spearman ρ = 0.14—and proposes measuring “Skill Lift” instead: run the same task with and without a skill under identical conditions and score the delta in completed work (paper summary via @omarsar0). In parallel, a position paper on Anthropic-style harnesses argues enterprises should standardize on a single reusable coding-agent harness rather than bespoke orchestration graphs, claiming harness choice can matter more than model choice on enterprise work (summary via @dair_ai).
• Persistent and self-modifying agents are moving from concept to open-source implementations: @andykonwinski introduced Headlong, an open-source “microharness” for persistent agents that think continuously rather than only on request. The system stores trajectories as a DAG of jsonl files, keeps a self-guided inner loop running, and reportedly achieved an unattended self-debugging repair in 48 minutes; tradeoffs include $1–$2/hr background thinking cost and occasional self-inflicted failures. Complementing that, @omarsar0 described exo, a harness architecture for recursive self-improvement with an append-only event log, swappable executor, and snapshot/rollback-capable sandbox—explicitly designed so agents can rewrite prompts/tools/memory without being able to corrupt durable state. Together, these posts suggest the next wave of agent infra is about durability, forking, rollback, and continuous operation, not just better prompting.
• MCP is maturing into enterprise infrastructure: Anthropic rolled out enterprise-managed auth for MCP connectors, centralizing authorization through the organization’s identity provider so end users no longer perform per-tool OAuth for connectors like Asana, Atlassian, Canva, Datadog, Figma, Notion, Slack, and Supabase (announcement from @ClaudeDevs). Separately, the MCP roadmap highlights upcoming support for long-running workloads with streaming/server push, HTTP for local servers, progressive discovery for large catalogs, and standard identities/delegated permissions (roadmap summary via @_philschmid). This closes a notable gap between toy demos and auditable enterprise deployment.

Model Releases, Leaks, and Competitive Positioning

• Qwen3.8-27B continues to punch above its size class: In Code Arena: WebDev, Qwen3.8-27B landed at #9 overall with 1595 points, the only model in its size class in the top 10 and just six ranks behind Qwen3.8-Max (leaderboard update from @arena). It also ranked highly in consumer product, brand/marketing, and gaming categories. A related open-source derivative, Carnice-V3-27B, was released by @kaiostephens: a 27B Qwen-based, Hermes-agent SFT intended to fit on consumer GPUs (3090+), with merged BF16 and GGUF variants.
• Rumor cycle around unreleased frontier models intensified: Multiple tweets referenced apparent early access or traces of unreleased systems: EAP models labeled “claude-melon-eap” and “claude-marshmallow-eap” reportedly emphasized 3D/RL-style tasks and used many thinking tokens (demo by @Lentils80); @kimmonismus collected signs of new Claude models, Ox Alpha, Qwen 4, and a confirmed GPT Astra; and @eliebakouch claimed access to a model still in training with a public W&B run. Treat most of this as ecosystem signal rather than verified spec, but it’s notable how much of the discourse is now about pre-release access asymmetry rather than public launches—echoing @michael_nielsen, who warned that controlling access to unreleased models is becoming a source of power concentration.
• OpenAI and Anthropic positioning remains in flux: OpenAI developers announced GPT-5.6 availability in Kiro and a claimed ~82% cost reduction per successful Terminal-Bench 2.1 task in Kiro’s spec-driven environment for the Terra variant (announcement). OpenAI also cut GPT-5.6 Sol API pricing to $4/M input and $20/M output tokens (pricing note via @kimmonismus), with Arena updates showing Sol and Luna shifting the cost/performance Pareto frontier (@arena). On the Anthropic side, @tenobrus noted there has not been an unambiguous Opus-line upgrade in over six months, even as external testers reported stronger medium-reasoning results from new Claude variants (@kimmonismus).

Inference, Benchmarking, and Cost-Efficiency

• Tool latency overlap is emerging as a key harness-level speedup: @a1zhang introduced Speculative Programmatic Tool Calling (sPTC), which predicts safe tool calls during code generation and launches them early in a copy of the environment so execution overlaps with token generation. The reported improvement is modest so far—about 1.0–1.2×—but the mechanism is important: it shifts optimization from token-level decoding tricks to agent workflow pipelining. @lateinteraction compared it to CPU speculative execution, emphasizing that discarded work is acceptable if most guesses are right.
• Token accounting and benchmark hygiene remain messy: Several posts called out misleading reporting practices. @bnjmn_marie shared a DeepSWE run with 918.9M input tokens, clarifying many were cache hits, while @cHHillee bluntly argued that counting cached input tokens in “token usage” is “incredibly dumb.” On the eval side, @jmbollenbacher warned that when a quantized model exceeds the reference model on a benchmark, it may indicate overfitting the quant, not genuine improvement; @xeophon summarized the broader lesson: fixing the eval may matter more than hill-climbing it.
• Cost-normalized agent benchmarks continue to reshape model choices: Together AI reported that under a $100 budget, GLM-5.3 completed 5× more work than Fable 5 on DeepSWE, roughly 17 vs 3 solved tasks, despite similar first-try performance (tweet). @reach_vb similarly reported GPT-5.6 Sol Max at 72.7% on DeepSWE v1.1 for $6.47/task versus Fable 5 Max at 69.7% and $21.63/task. Cline also compared Ox Alpha vs Fable on a real bugfix and found both solved it, but Ox used roughly 3× fewer output tokens, suggesting a notably different post-training philosophy around re-verification versus acting on the first conclusion (comparison from @cline).

On-Device AI and Inference Systems

• Liquid AI + Artificial Analysis launched a serious on-device benchmark stack: @liquidai released Pipette, an open-source evaluation suite for on-device inference measuring quality, speed, latency, and memory across model + quantization + runtime + device combinations, with 10k+ verified results spanning 35 model classes, 7 quants, llama.cpp runtimes, and four devices. Artificial Analysis paired this with independent phone-scale intelligence evals on iPhone 17 Pro and Galaxy S26 Ultra (full thread).
• Phone-scale results highlight a different Pareto frontier than cloud evals: Under an 8 GB memory / 16K context framing, Nanbeige4.2-3B and LFM2.5-2.6B topped the average score at 63, with LFM2.5-2.6B much more efficient on iPhone (8.0s, 2.3 GB) than Nanbeige (21.4s, 4.0 GB). MoE designs such as LFM2.5-8B-A1B and Ling 3.0 Tiny are notable because they activate ~1B parameters/token, enabling sub-6-second responses on phone hardware. The evaluation also makes explicit that many “smart” reasoning models are poorly matched to mobile memory and latency constraints.
• Inference vendors are competing on agent-specific throughput, not just raw TPS: NVIDIA’s Groq 3 LPX was described as adding a dedicated token-generation accelerator to Vera Rubin, with a claimed 3,400 output tokens/s on Gemma 4 31B at 100K context in Artificial Analysis benchmarking (summary via @kimmonismus); Groq said it will be among the first to deploy it in production (announcement). Separately, vLLM published extensive AgentX 1.0 results on real multi-turn coding traces, emphasizing KV offload, prefix reuse, and prefill/decode disaggregation as the keys to high agentic throughput rather than classic single-turn serving metrics (@vllm_project).

Research, Papers, and Technical Education

• RL for LLMs and harness-native training remain hot: @cwolferesearch published a comprehensive reinforcement learning guide covering token-level vs completion-level formulations, PPO/GRPO variants, actor-critic methods, rubric-based RL, and agentic RL/world modeling. This coincides with growing attention on “harness-native” RL and agent environments, reflected in paper roundups like @TheTuringPost and discussion of papers such as Agent Lightning, LEGO-RL, EnvHarness, and SkillGate.
• Other notable research threads: Meta/USC’s Periodic Row-wise Muon extends Muon optimization to larger diffusion transformers by amortizing expensive Newton–Schulz updates while keeping gains over AdamW (summary via @iScienceLuvr); Adobe’s Latent Dynamics Reasoning learns extrapolative video world models from pixels by modeling latent state evolution instead of direct future prediction (paper via @_akhaliq, authors’ note); and Cartwheel reported compute-optimal scaling laws for human motion generation, arguing motion may become the fifth modality with Chinchilla-like scaling behavior (launch).
• Educational content worth saving: @fchollet recommended chapters 15–16 of Deep Learning with Python as one of the best accessible explanations of why dot-product attention works; @ProfTomYeh posted a detailed by-hand walkthrough of self-attention; and @mervenoyann announced a new home for llama.cpp docs, with upcoming material on speculative decoding, quantization, and coding agents.

Top tweets (by engagement)

• Hands-on product/UI performance: Anthropic said long answers in Claude web/desktop now stream ~4× smoother, with 9× fewer stalls and 4.5× shorter worst freezes on slower laptops (announcement).
• Fast image generation UX: @samdape showed a technique to make GPT image generation draw faster.
• OpenAI research culture: @gdb amplified a post from @kundan2510 praising OpenAI’s willingness to sustain long-term bets like full-duplex models.
• Learning resources: @fchollet recommending attention chapters from Deep Learning with Python was one of the highest-signal educational posts in the set.
• Enterprise MCP: Anthropic’s enterprise-managed auth for MCP connectors was one of the most consequential platform updates for production agent deployment (announcement).

• “Qwen 3.8 isn’t Opus level”: I re-ran the test. (Activity: 911): The image (link) shows the Deepseek/pi.dev-style coding harness being used with qwen3.8-27b in “Plan” mode for a C#/OpenGL ocean-rendering task, supporting the post’s claim that harness quality strongly affects observed model capability. In the author’s rerun, the same Qwen3.8 model and prompt failed under VS Code Copilot with a black screen, but succeeded under the alternate harness, reportedly using screenshot feedback and even generating a PNG decoder when vision was not enabled, producing waves, sky, sun, and underwater view in about 1 hour on an RTX 5090 running an ninfer-nvfp4 build with ~190k context at ~150–180 tok/s. Commenters largely agreed that the result demonstrates a large gap between “lazy” or sandboxed coding harnesses and agentic harnesses with execution/screenshot feedback. The original critic of Qwen3.8 conceded the prior conclusion was wrong and began retesting with pi.dev, noting fewer crashes and lower RAM use than VS Code/BYOM with llama.cpp.A key technical theme was that harness quality can dominate perceived model capability: commenters noted Qwen 3.8 apparently implemented an “on the fly PNG decoder” and still produced working ocean shaders despite an initially misconfigured or limited execution setup. The discussion framed this as evidence that sandboxed tools like Copilot-style environments may under-represent what coding agents can do when given a proper runtime/test loop.The original tester reported switching from VS Code + BYOM talking to llama.cpp to pi.dev after acknowledging the earlier harness was inadequate. They observed two concrete issues in the VS Code setup: driver errors after spawning the test executable, and random VS Code crashes while llama.cpp RocM 1200 build from Lemonade SDK continued running without output errors; by contrast, pi.dev had not crashed and used noticeably less RAM.Several commenters compared agent harnesses such as pi.dev/OhMyPi, opencode, and local llama.cpp setups, with interest in how much autonomy the harness provides beyond a standard Claude-like chat workflow. Hardware constraints also came up: users speculated that a RTX 5090 or similar high-end local GPU setup, potentially with tools like Ninfer, could make local agentic coding workflows more viable without cloud subscriptions.
• New qwen3.8:27b on a 39k line C to single-file HTML / three.js port (Activity: 655): A one-shot agent benchmark attempted to port a 2.1 MB / 39k-line / ~600k-token single-file C procedural shooter (skill-issue) into single-file HTML/Three.js, where the source was >2× the available 262,144 token context. On RTX 6000 Pro 96GB with vLLM, FP8 weights and FP8 KV cache, Claude Code + Opus 5 produced the only “okay” port in 21 min / 1759 LOC, while qwen3.8:27b via hermes took 4h18m / 949 LOC and via codehamr (repo) took 1h40m / 1056 LOC, both judged “bad.” Commenters suggested that direct “convert this code” prompts cause models to re-imagine behavior; a more reliable pipeline is to first generate a transpiler, get runnable target-language output, then iteratively rewrite function-by-function against high-level pixel comparisons or low-level register/state references. Technical debate centered on whether the poor local results were due more to prompt/harness design, missing decomposition/tests, or inference setup: multiple commenters warned that FP8 KV-cache quantization may significantly degrade long-context performance and suggested rerunning without it. Others argued the wall-clock gap is expected because Anthropic can parallelize across far more hardware, and recommended measuring vLLM tokens/sec, planning first, splitting the monolithic C file into modules, and adding behavioral tests before porting.Several commenters argued that direct “convert this codebase” prompting causes models to re-imagine the source rather than preserve behavior, even with frontier models. A suggested workflow is to first have the model help write a transpiler to the target language, then iteratively rewrite function-by-function while validating against high-level pixel comparisons or low-level register/value traces to reach pixel-perfect equivalence.Multiple comments questioned the inference setup, specifically FP8 KV-cache quantization, Q8, and not running the full bf16 Qwen 27B model on an RTX 6000-class GPU. The concern was that KV-cache compression/quantization could introduce severe quality issues for a long-context code-porting task, and that rerunning without FP8 KV-cache or with full bf16 would better isolate model capability from quantization artifacts.One technical explanation for the long runtimes was repeated KV-cache reprocessing in vLLM: if the engine releases the session cache, it may spend minutes recomputing prior context before generating any new tokens. A commenter suggested using LMCache to persist KV-cache in RAM, noting that cloud providers often avoid this latency by caching processed context across turns.