TNP - 2026-11-12

Welcome to Trending Not Peak for Thursday, November 12. Today, a browser tab becomes a model runtime, and a painting app shares its brushes with an agent. AI assisted with the writing, and this voice is synthetic. Explore the stories at trending not peak dot com.

Take PyTorch models straight to the browser GPU

First up, ExecuTorch has a new WebGPU backend that gives PyTorch models a direct route into a browser tab. Export through PyTorch to an ExecuTorch model file, then run that artifact in a WebGPU-enabled browser. You don't have to convert it into another framework's format along the way. The announcement describes support spanning language models, image segmentation and Whisper speech recognition. For web developers, that opens some lovely possibilities: a photo tool that processes pictures on the device, or transcription that doesn't send recordings to an inference server. PyTorch's team reports four to seven times faster prefill and two to ten times faster decoding than its CPU path on the same machine. Those are backend comparisons, with results depending on the workload and hardware. ExecuTorch gives you a concrete way to run models in browsers. Start with one supported model in the playground, then explore what happens when its inputs and outputs stay inside your application’s tab.

Evaluate agents on visually dense professional files

Next up, Multimodal Knowledge Agent, or MKA, tests a different kind of agent competence: can it read a workspace full of visual files and produce a useful professional deliverable? Artificial Analysis has launched its implementation of Google DeepMind's benchmark, with two hundred tasks across ten industry verticals. Inputs include architectural drawings, engineering schematics and clinical scans. Outputs can be reports, spreadsheets or marked-up drawings. That's relevant if you're building document agents whose important information disappears when a file becomes plain text. Each run gets a Linux sandbox and up to two hundred fifty turns. The headline score measures the weighted share of harder rubric requirements satisfied, rather than the percentage of completely solved jobs. The leading listed model reaches fifty-seven percent on that measure. Evaluation teams could use the example tasks to design their own checks around actual files and deliverables. Ask whether the agent noticed the dimension on the drawing, then inspect whether that detail survived into its finished work.

Peek at assembly without leaving Neovim

Closer to the editor, AssemblyForNeovim puts compiler output in a floating window beside your code. The small Lua plugin supports C, C-plus-plus and Rust, with x-sixty-four and ARM sixty-four assembly. Point it at the function under your cursor or select a few lines. Inside the window, you can change the optimization level and rerun compilation. It uses your installed compilers and picks up a compilation database when one is present. Systems programmers and people learning performance work could use AssemblyForNeovim to inspect compiler output while an idea is still fresh. Does that little helper disappear after optimization? Does changing an expression change the generated instructions? The plugin gives you a quick place to look. Assembly alone won't tell you the speed of a complete application, but it can help you choose the next question to measure.

A robot policy gets a smaller inference footprint

Turning to robot models, Runway's Praxis-one YAM checkpoint offers an experimental lower-precision path for a twenty-seven-billion-parameter policy. This version targets a two-arm robot setup with a top camera and cameras at each wrist. It received five thousand additional training steps with quantization-aware training on the routed expert layers. The model card says the policy's in-memory size falls from fifty-four point four gigabytes to seventeen point five when those experts run in NVIDIA's four-bit format. Robotics researchers with matching hardware get a specific artifact to investigate when fitting a policy onto a smaller GPU. There's a consequential hardware boundary: this experimental inference path supports SM-one-twenty GPUs, including the RTX fifty-ninety and RTX PRO six-thousand Blackwell. The full fifty-four-point-four-gigabyte checkpoint still downloads before packing at load time. A useful experiment would compare the same manipulation tasks in both precision modes, checking action quality alongside memory. Smaller weights earn their place when the robot still performs the task.

Thanks to Intelligrit

Thanks to Intelligrit, this episode's sponsor, for supporting Trending Not Peak. Take your next curious click to intelligrit dot com.

Aim the red team at the boundary you need tested

Back from the break, Perplexity's Escaping SPACE, Part Two has a useful finding about testing agent sandboxes: the challenge wording can change what your red team actually investigates. Its experiments ask models to cross a virtual-machine boundary or bypass network restrictions. In capture-the-flag tasks, the researchers observed agents spending substantial effort hunting for the secret string instead of examining the intended security mechanism. Explicitly directing them toward that boundary shifted their effort. The expanded evaluation now includes twelve models. Earlier experiments found network bypasses, which Perplexity says it fixed and retested; none of the original nine models escaped the virtual machine. For teams evaluating code-execution environments, the new possibility is a better-designed test. Compare a flag-focused task with a boundary-focused one, then inspect the attempted approaches. A model that searches enthusiastically isn't necessarily putting pressure on the part of your system you meant to assess.

Give a data agent a specialized prediction tool

Over at the learning bench, DeepLearning.AI and Prior Labs have a new course on giving a data science agent a tabular foundation model. The course uses TabPFN, an open-weight model that makes predictions from dataset examples through in-context learning. You can explore classification and regression without training a separate model from scratch for each dataset. The agent's role is to understand the request and hand the prediction work to that specialized tool. That's an approachable architecture for developers building assistants around structured records. The lessons also cover interpreting predictions and caching the training context for repeated queries. Across eight video lessons and four code examples, there's a practical route from a table to an agent integration. Use a dataset with known outcomes and compare predictions on held-out rows. The interesting question is whether the agent chooses the right statistical task and whether the prediction tool earns your confidence on that data.

Compile visual flows onto a microcontroller

Heading out onto the workbench, ThingStudio brings visual flow programming to microcontrollers running MicroPython. You arrange events and operations on your computer, then it compiles the flow into code and sends it to the board. Close the editor, and the saved program keeps running. The beta lists support for ESP-thirty-two, Raspberry Pi Pico chips and several other microcontroller families. Makers who already know a little programming could use ThingStudio to build microcontroller flows without manually managing every event in a growing loop. Its example combines a button-controlled light with timed sensor readings and network messages. The browser demo lets you build a flow and read the generated MicroPython before installing anything. Real-board execution requires the installed tool. The project is Apache licensed and designed to work locally, including offline documentation. Pick a sensor project you understand, inspect the generated code, and see whether the flow makes concurrent events easier to follow.

Share a painting's brushes with a coding agent

For a more colorful workspace, Klad is a two-dimensional painting and animation app that a person and a coding agent can share. You draw with a pen in the editor. The agent draws through a command-line interface, using the same brushes on the same drawing, with each participant seeing the other's strokes immediately. Artists who code, game developers and interface experimenters have a concrete collaboration model to explore here. You could sketch a small scene and ask an agent to add a bounded visual element, then continue painting over its contribution. Klad is source-available, so check its license before planning a derivative product. The useful experiment is whether shared brush operations make a visual instruction easier to express and revise. A canvas gives you somewhere to point when words become awkward.

An old Windows game takes a native ARM route

And finally, bo2-mac takes Call of Duty: Black Ops Two on an unusual compiler journey, from thirty-two-bit Windows instructions to native ARM sixty-four macOS. The project describes lifting the game through Remill into LLVM's intermediate representation, supplying a handwritten Windows runtime, and drawing Direct-three-D eleven graphics through Metal. Its beta targets campaign, Zombies and multiplayer against bots, built on your Mac from your own Steam copy. The repository includes no game files. Compiler enthusiasts and game-preservation tinkerers get an interesting system to inspect: translating instructions is only part of making an old program feel at home. Operating-system calls and graphics need somewhere to land too. The beta identifies measurements on one sixteen-gigabyte Apple M-one machine, so broad compatibility remains a question. Follow one piece of that runtime glue. An old game has brought quite a bit of Windows baggage on its Mac vacation.

A few possibilities for your next project: ExecuTorch to run models in browsers, AssemblyForNeovim to inspect compiler output, and ThingStudio to build microcontroller flows. Find the projects and their details at trending not peak dot com. This is Trending Not Peak. Have fun finding out what your tools can do.