[AINews] Andrew Ng gets into AI Engineering

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.** 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 requireshaving 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, andand take longer in order to build more carefully.”when to slow downThis 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 2024and 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!

AI Twitter Recap

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 justSpearman ρ = 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 onAnthropic-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:@andykonwinskiintroduced** 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 in48 minutes; tradeoffs include**$1–$2/hr** background thinking cost and occasional self-inflicted failures. Complementing that,@omarsar0describedexo, 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 aboutdurability, 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 forlong-running workloads with streaming/server push,** HTTP for local servers**,** progressive discoveryfor 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-27Blanded 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);@kimmonismuscollected signs ofnew Claude models,** Ox Alpha**,** Qwen 4**, and a confirmed** GPT Astra**; and@eliebakouchclaimed 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 aboutpre-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.6availability 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 cutGPT-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,@tenobrusnoted 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:@a1zhangintroduced** 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—about1.0–1.2×**—but the mechanism is important: it shifts optimization from token-level decoding tricks to** agent workflow pipelining**.@lateinteractioncompared 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_marieshared a DeepSWE run with918.9M input tokens, clarifying many were cache hits, while@cHHilleebluntly argued that counting cached input tokens in “token usage” is “incredibly dumb.” On the eval side,@jmbollenbacherwarned that when a quantized model exceeds the reference model on a benchmark, it may indicateoverfitting the quant, not genuine improvement;@xeophonsummarized 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.3completed 5× more workthan Fable 5on DeepSWE, roughly 17 vs 3 solved tasks**, despite similar first-try performance (tweet).@reach_vbsimilarly reportedGPT-5.6 Sol Max at72.7% on DeepSWE v1.1 for**$6.47/task** versusFable 5 Max at69.7% and**$21.63/task**. Cline also compared** Ox Alpha vs Fableon 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:@liquidaireleased** Pipette**, an open-source evaluation suite for on-device inference measuring** quality, speed, latency, and memoryacross model + quantization + runtime + device combinations, with 10k+ verified resultsspanning 35 model classes**,** 7 quants**, llama.cpp runtimes, and four devices. Artificial Analysis paired this with independent phone-scale intelligence evals oniPhone 17 Pro andGalaxy S26 Ultra(full thread).** Phone-scale results highlight a different Pareto frontier than cloud evals**: Under an** 8 GB memory / 16K contextframing, Nanbeige4.2-3Band LFM2.5-2.6Btopped 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-A1Band Ling 3.0 Tinyare 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 LPXwas described as adding a dedicated token-generation accelerator to Vera Rubin**, with a claimed** 3,400 output tokens/son Gemma 4 31Bat 100K contextin Artificial Analysis benchmarking (summary via @kimmonismus); Groq said it will be among the first to deploy it in production (announcement). Separately, vLLM published extensiveAgentX 1.0** results on real multi-turn coding traces, emphasizingKV 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:@cwolferesearchpublished 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@TheTuringPostand discussion of papers such asAgent Lightning,** LEGO-RL**,** EnvHarness**, and** SkillGate**.** Other notable research threads**: Meta/USC’s** Periodic Row-wise Muonextends Muon optimization to larger diffusion transformers by amortizing expensive Newton–Schulz updates while keeping gains over AdamW (summary via @iScienceLuvr); Adobe’sLatent 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 reportedcompute-optimal scaling laws for human motion generation, arguing motion may become the fifth modality with Chinchilla-like scaling behavior (launch).Educational content worth saving:@fcholletrecommended chapters 15–16 ofDeep Learning with Pythonas one of the best accessible explanations of why dot-product attention works;@ProfTomYehposted a detailed by-hand walkthrough of self-attention; and@mervenoyannannounced a new home forllama.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 stallsand 4.5× shorter worst freezeson slower laptops (announcement). Fast image generation UX**:@samdapeshowed a technique to make GPT image generation draw faster.OpenAI research culture:@gdbamplified a post from@kundan2510praising OpenAI’s willingness to sustain long-term bets like full-duplex models.Learning resources:@fcholletrecommending attention chapters fromDeep Learning with Pythonwas 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).

AI Reddit Recap

/r/LocalLlama + /r/localLLM Recap

1. Qwen 3.8 27B Coding and Quantization Benchmarks

(Activity: 911):“Qwen 3.8 isn’t Opus level”: I re-ran the test.The image (link) shows the Deepseek/pi.dev-style coding harness being used withqwen3.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 about1 hour

on an RTX 5090 running anninfer-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 withpi.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 toafter 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 whilepi.devllama.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.cppsetups, with interest in how much autonomy the harness provides beyond a standard Claude-like chat workflow. Hardware constraints also came up: users speculated that aRTX 5090** or similar high-end local GPU setup, potentially with tools likeNinfer, could make local agentic coding workflows more viable without cloud subscriptions.

(Activity: 655):New qwen3.8:27b on a 39k line C to single-file HTML / three.js portA one-shot agent benchmark attempted to port a2.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 available262,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 in21 min

/1759

LOC, while qwen3.8:27b via hermes took4h18m

/949

LOC and via codehamr (repo) took1h40m /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 thatFP8 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-imaginethe 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 usingLMCache to persist KV-cache in RAM, noting that cloud providers often avoid this latency by caching processed context across turns.