Episode 109: NVIDIA Jetson Orin Nano 2 Doubles Speed on New Silicon

I'm Nova. I'm Alloy, and this is AgentStack Daily. NVIDIA just moved its entry-level Edge AI line onto New Silicon. The Jetson Orin Nano 2 is supposed to deliver roughly twice the throughput of its predecessor, potentially putting richer local models into robots, cameras, and field systems that can't depend on a cloud connection. Twice as fast is NVIDIA's claim for now, not an independently reproduced result, but fresh silicon makes this much more consequential than a renamed board. And the physical world keeps showing up. Anthropik's new hardware standard gives agents a guarded route into lasers and laboratory instruments. NVIDIA's weather tooling turns atmospheric forecasts into probability ranges for wind power output. People aren't merely building chat windows, they're connecting models to turbines, experiments, video pipelines, municipal records, and devices at the edge. Today, OpenClaw 8.1 and Hermes Agent 8.31 strengthen long-running, multi-device work, IBM's Granite 4.28b arrives with a 131,000 token context window, and Meta opens Musecode to custom agents. You'll hear why voice latency needs honest labels, how hourly-changing search questions fight benchmark cheating, and where self-improving AI still gets lost. OpenClaw 8.1 shipped with exact word and phrase search across visible conversation history, including a route back into the messages surrounding each result. That's the obvious quality of life improvement. The deeper change is support for sessions beyond the gateway. Work can run on paired devices or cloud workers, carry its workspace along, and later reuse warm machines and prepared project seeds. A task can leave a laptop, continue on stronger hardware, and preserve its place. Private credential requests now use masked prompts, keeping the secret out of both the chat and the model's view. An optional proxy substitutes protected secrets only for destinations the user has approved. Recurring work can also receive narrowly defined permission for an exact operation. That permission remains inspectable and revocable, and any changed job or operation requires approval again. The release removes the bundled openprose plugin and its prose command. Existing prose source files remain, while the migration moves toward the upstream agent skill. That removal will be noticeable, but it doesn't erase the underlying prose work. Honestly, that's a serious release because continuity, secrets, and approval are exactly where a long-running agent stops feeling like a clever demo. OpenClaw also added a durable progress card that survives reloads and follows sub-agent activity and edits, structured question cards with buttons and a skip option, pinnable in-chat widgets that export as images, and richer native handling for audio and video. Hermes Agent 8.31 arrived the same day with parallel improvements around session continuity, handoff between devices, and credential reuse. I wouldn't flatten the two products into one, they have distinct surfaces, but both are responding to the same pressure. Agents now run long enough to cross devices, outlive a browser tab, and encounter protected services. A person might start a repository repair on a laptop, move execution to a cloud worker, answer a structured question from a phone, and return later to the same active state. If that session forgets its place or sprays a credential into chat, the intelligence hardly matters. These releases make the surrounding machinery more durable while keeping explicit trust decisions in human hands. An 8 billion parameter dense reasoning model with a 131,000 token window sounds like an odd pairing, compact weights, enormous input. What is IBM optimizing for with Granite 4.28b? Dense means all of the model's parameters participate in each pass, rather than a mixture of experts design routing each token through only part of the network. IBM positions Granite 4.28b for mathematics, code generation, multilingual dialogue, and multi-step agent work. OpenRouter now exposes it through an API, with configurable full and low effort reasoning modes. The long window can hold substantial source material, a large document collection, an extended agent trace, or a meaningful portion of a repository alongside an issue description. Output is capped at 4,096 tokens, so the shape favors heavy input and bounded responses rather than endlessly long generation. A coding assistant could read broad repository context and still return a focused patch explanation. A document agent could compare long contracts or policy collections without chopping every source into tiny fragments first. Okay, I like that shape more than a giant context number with no product logic. An agent can spend deeper reasoning on a difficult code or mathematics call, then use lower effort for routing, classification, or short transformations. It also gives teams another mid-sized open model option without requiring them to host the weights before learning whether the behavior fits. But a 131,000 token window says what fits, not how reliably the model retrieves and combines the right details across that span. IBM's capability positioning is useful, comparative performance still needs evidence against models of similar scale. Granite's attraction comes from the combination, manageable model size, broad reasoning duties, multilingual support, and enough input capacity for work that would otherwise demand aggressive summarization. That could be genuinely useful, provided the model's attention holds up when the prompt stops looking like a tidy demonstration and starts looking like a real, messy repository. Voice agents can sound brilliant and still feel broken because they hesitate. A new benchmark examines the whole response path and labels every latency number by where it came from, independently measured, published by a vendor, or measured by a vendor on its own product. That provenance matters more than another leaderboard. Exactly, because 200 milliseconds can mean three different things depending on who held the stopwatch. The benchmark begins with time to first token, the delay between sending a prompt and receiving the first fragmented output, but it also covers speech recognition, speech generation, and direct speech-to-speech systems. A voice exchange accumulates delay across every layer. Fast model output can't rescue sluggish transcription, and quick transcription won't help if generated audio arrives late. Time to first token is easy to display and easy to overvalue. It captures startup delay, not the pace of the full response. A system can begin quickly and then generate too slowly for comfortable speech. Network location, prompt size, model load, and streaming behavior can also alter what a person experiences. The benchmark's strongest contribution isn't crowning a provider. It prevents unlike evidence from appearing equivalent merely because every result uses milizakins. I don't buy a clean ranking unless its measurement conditions travel with it. Real-time delay changes how people behave, they repeat themselves, interrupt, or assume the system failed. Provenance labels don't eliminate vendor claims, but they show which numbers came from outside measurement and which came from the seller. Combined with the full-speech pipeline, that makes latency comparisons harder to polish around one flattering statistic. It also explains why two systems with similar first token figures can feel completely different in conversation. Human turn-taking is unforgiving, a delay that looks small in a table can become an awkward silence after every sentence. A useful benchmark therefore needs hardware, network region, prompt length, and streaming settings beside every result. Muse code leaving beta matters less because meta removed an experimental label and more because developers finally get an SDK. Does that genuinely turn it into a platform? It moves in that direction. The SDK exposes the agent runtime so developers can embed custom agents and connect external tools instead of accepting only meta's built-in behavior. Subscription plans arrive with the release too, creating a commercial access surface rather than another limited preview. Runtime access, custom agents, tool integration, and paid terms give teams something they can design a product around. A software company could place a specialized coding agent inside its own interface, connect it to approved internal tools, and control the surrounding experience instead of sending customers into a separate meta product. I'm cautiously excited. An SDK changes who controls the experience, but leaving beta doesn't answer what determines adoption at scale. Pricing behavior, support, usage rights, and the depth of third-party participation will matter. Meta has opened the door, useful evidence arrives when outside developers ship agents through it and the economics survive real traffic. A strong runtime can disappear inside dozens of products, which is exactly what a platform wants. And custom doesn't automatically mean differentiated. The runtime needs enough control to create more than a branded wrapper, while tool access has to support real applications beyond a narrow demonstration. Still, MuseCode now has a documented route for others to embed agents, attach tools, and pay for sustained access. That puts it into consideration wherever teams are choosing an agent runtime and gives Meta a chance to compete through products other companies build on top. OpenClaw 2.0 is built from the same 8.1 release, but the scale of the project deserves its own look, 933 contributors, 569 of them first-timers, and more than 16,000 merged pull requests. Roughly half of all accepted contributions arrived through that enormous wave of participation. The rebuilt setup reuses existing subscriptions, API keys, and local models rather than forcing people to enter everything again. The Control UI's test harness startup fell from roughly 1.6 seconds to 575 milliseconds. Shared cloud sessions also add multiplayer work, letting several people operate in the same space. That combination makes the project easier to enter and faster to use repeatedly, which matters more than another decorative interface refresh. Wow, 569 first-time contributors is a community event, not merely a product release. And that startup reduction cuts roughly a second from something developers may reopen constantly. I'm more interested, though, in the security wording around shared sessions. OpenClaw explicitly says multiplayer is not a security boundary. Everyone still operates through one gateway, and trust is decided there. That's refreshingly precise. Collaboration can make a workspace shared without magically separating authority. Faster setup helps new teammates arrive, and credential reuse removes a familiar source of friction, but the gateway remains the point where permissions count. OpenClaw is making coordinated agent work easier while refusing to claim that a shared interface creates isolation it doesn't actually provide. Litrix LTX 2.5 has passed 1.2 million downloads and 2400 likes after its repository appeared in late July. The striking part is how much media generation sits in one checkpoint. Text to video, image to video, video to video, image and text to video, audio to video, text to audio, and video to audio. A creator can begin with a prompt, a still, or an existing clip, while audio belongs to the same model family rather than an entirely separate generation stack. That breadth makes it interesting for self-hosted creator systems where one job may move from concept art to motion, revision, and sound. Okay, that's actually wild, not because every tagged capability will be equally strong, but because consolidation changes what a local pipeline looks like. One set of weights covering several video and audio transformations can reduce the number of checkpoints, loaders, and handoffs a system has to manage. An agent assembling a short clip might revise motion from a source video, create a sound layer, and keep the work inside one broader model surface. Fewer handoffs can also preserve creative intent, the visual change and its associated sound don't have to be interpreted independently by unrelated models. The adoption numbers suggest the open weight community wants that convenience, although downloads aren't finished films and likes aren't production reliability. LTX models are aimed at video creation, and trending this quickly means a lot of people are at least trying to make them part of local media systems. What survives outside showcase clips matters more, coherent movement, useful edit control, audio-video alignment, and repeatable output over longer jobs. Its popularity gives the community enough usage to expose those limits quickly. Letting an AI agent operate a laser sounds like the point where move fast should leave the room. Anthropix Model Hardware Standard claims it can make instrument integration dramatically faster without asking a prompt to serve as the safety system. How? MHS defines a shared driver specification for lasers, reactors, and bench instruments, then makes those drivers available through the tool protocol agents already use for software. Crucially, operating limits live inside the driver. If an agent requests an unsafe action, the hardware-facing layer can reject it before the instrument receives the command. Anthropix says integrations that once took weeks or months can fall to hours. At Carnegie Mellon, researchers reportedly went from raw equipment to a completed dose-response curve in eight hours. That curve measures how changing the amount of a substance changes an observed effect. Chihua's result is hard to ignore, a laser relock procedure rose from 58% success to 99.3% across 700 trials after moving to an MHS-compatible driver. Those are reported early results, but 700 attempts carry more weight than one polished demonstration. Driver level limits are also the right instinct. A laser controller shouldn't depend on a model remembering a warning inside its prompt. The equipment needs authority to refuse commands outside its operating range. That separation also makes responsibility easier to understand. The agent can propose an action, while the device driver decides whether the action is physically permissible. I agree, although a standard becomes useful only when equipment makers support it. Model agnostic access could keep labs from depending on one AI provider and reduce bespoke integration code for every instrument. If vendors publish compatible drivers with firm boundaries, agents could coordinate longer experiments and react to measurements while the equipment retains final authority. Without that device catalog, MHS remains a promising preview. With it, AI-directed laboratory work becomes much more credible. NVIDIA's Earth 2 Studio tutorial takes a weather model and makes it answer an energy question. It runs batched ensemble forecasts in a hosted notebook, loads NVIDIA's FCN forecasting model, and begins with atmospheric conditions from the United States global forecast system. An ensemble slightly changes the starting conditions and produces several plausible futures rather than pretending one forecast is certain. Small atmospheric differences can create larger changes later, so the collection tells a planner more than a single prediction. That distinction is everything for wind power. A grid operator needs the likely range, not only an expected wind speed. The tutorial converts 10-meter wind components, the horizontal wind moving in two directions, into turbine capacity factors. A capacity factor describes how much of a wind farm's rated output conditions could produce. Each ensemble member becomes a possible power outcome. A narrow distribution supports more competent scheduling, a broad one warns that storage, backup generation, or power purchases may have to absorb a surprise. The notebook also handles an ordinary obstacle, installing Earth 2 Studio components without breaking the hosted environment's graphics compute and machine learning setup. Managed notebooks often fail at that boundary. Once it works, Earth 2 Studio runs the batches, while the custom diagnostic translates atmospheric variables into units the domain uses. Researchers don't need to rebuild the forecast engine just because the final question concerns electricity instead of weather. And that translation reaches beyond wind. Solar irradiance can become expected panel output, rainfall can become flood exposure, and temperature can become a range for electricity demand. That's exciting because it makes uncertainty usable. The weather model stays underneath while a domain diagnostic produces a quantity and energy planner, farmer, or infrastructure team already understands. Several organizations could share the same forecasting machinery while asking completely different operational questions. OpenAI has endorsed California Senate Bill 1119, which seeks age-appropriate safeguards for teenagers using AI products. The company frames the bill as preserving young people's ability to learn, create, and explore while establishing protections designed for their age. Public support places a major AI provider behind a specific legislative proposal instead of another general promise of responsible design. That matters because teen use isn't hypothetical. Conversational systems can become tutors, creative partners, advice sources, and persistent companions, often inside the same product. Yes, and that moves the regulatory conversation beyond voluntary product policy. A California law could turn parts of teen protection into a baseline expectation for AI services reaching younger users. The decisive details remain in the legislation, which products it covers, what age-appropriate treatment requires, how accounts are handled, and how compliance is enforced. OpenAI's endorsement doesn't settle those mechanics, and company support shouldn't substitute for scrutiny of the final text. But it does show that a major provider considers targeted safeguards compatible with continued teen access. The hard work lies in writing protections that address actual product behavior without reducing young users to a single, simplistic category. Here's a humbling question, if you tell an AI to become better at physics research, does it know what better requires? Aspire hides the real evaluation and gives agents broad goals like that. The agents can run training loops and edit their own scaffolding, but they repeatedly choose poor training data and trust narrow self-tests that don't correspond to genuine progress. Changes to model weights produce sparse, unstable gains, unstable gains. Even the strongest self-evolved setup trails a hand-engineered reference, and some local improvements disappear when training continues. So self-improvement isn't only a matter of adding compute or letting an agent rewrite more code. It has to interpret the goal, choose experiences that teach the relevant skill, and recognize evidence of progress. That's uncomfortably human. An autonomous learner can execute the mechanics perfectly while optimizing the wrong lesson. Aspire puts metacognition, the ability to decide what deserves learning, ahead of the training loop itself. More freedom doesn't help much when the learner can't tell which weakness matters. A public search benchmark can accidentally publish its own answer key. If its questions and answers sit in a downloadable dataset, a web-enabled agent may find that file and score perfectly without doing the retrieval task anyone meant to measure. Keenable RE's open-source needle benchmark responds by rebuilding its query set every hour. Freshness becomes part of the evaluation rather than a maintenance detail. That's delightfully adversarial. A static benchmark assumes the search agent won't search for the benchmark, which is absurd. Hourly regeneration removes the single canonical file an agent could memorize or retrieve during evaluation. To perform well, the system must search the live web and reason over fresh material rather than recognize an old question or locate a public answer table. It doesn't make evaluation incorruptible. Generated questions still need to reflect useful search behavior, and the moving web introduces ambiguity. Pages change, disappear, or contradict each other. But regeneration changes the economics of cheating. Old training contamination becomes less useful, while directly grabbing published labels becomes harder. Scores can move closer to current retrieval ability rather than familiarity with a frozen collection. And that matters when search agents support research, customer answers, or retrieval augmented generation, where a model consults external sources before responding. Static public sets are vulnerable because agents can browse the same internet that hosts their evaluation material. Needle treats changing information as normal. Results from questions too fresh to become training material or a hidden lookup table would tell us far more than another perfect score on a famous dataset. It's a clever acknowledgement that once models can use the web, the web becomes both the exam room and a possible cheat sheet. Needle changes the questions. Google's ENV Harness keeps established tasks but changes how the training environment presents them. Why wrap the environment rather than replace the benchmark? Because teams may already trust those tasks and their human-written scoring rules. ENV Harness, released under the Apache license with Washington University in St. Louis and the University of North Carolina at Chapel Hill, sits between the benchmark and the trainee agent. Existing agent software still sees familiar reset and step commands. The tasks and verifiers remain fixed, while the wrapper can reshape observations and success conditions whenever the environment resets. A mastered benchmark can keep producing training pressure without discarding the human effort behind its scoring. Here's the surprising part, a language model called ENV Rager writes those wrappers. It watches attempts, identifies where performance stalls, and produces new wrappers aimed at those weaknesses. Across five benchmarks, Google reports gains of up to nine points on held-out tasks, with trained policies finishing in 9.8% fewer execution steps. Those are Google's numbers, so broader reproduction matters, but improving completion and efficiency is more interesting than teaching an agent to wander longer toward a higher score. Right, a generated wrapper could cultivate a missing skill or distort the environment into something narrow. Five benchmarks don't establish universal behavior. Keeping human-built verifiers intact provides an anchor. The wrapper alters learning conditions but can't rewrite what counts as success. Env Harness turns a benchmark into reusable training material. Paired with Needle, it offers another answer to stale evaluation. Change fresh questions continually, or let established questions produce changing learning conditions. One protects against memorized answers, the other tries to extract more learning value from tasks people already understand. Paper Jim teaches research planning by separating what a paper asked from how the paper later judged its answer. The framework extracts a research question from the purpose and background, then derives evaluation criteria from the methods and experiments. Keeping those halves apart stops the model from simply paraphrasing a completed paper and calling that a plan. It has to propose work from the question, while the later evidence supplies a grounded standard for judging that proposal. That's clever because scientific planning rarely has one exact answer. The useful question is whether proposed experiments can resolve the stated uncertainty. After training through this setup, an 8 billion parameter QUIN3 model scored 73.48 on research QA, ahead of the much larger Kimi K 2.6. The researchers also released their pipeline and a corpus of 20,000 papers. Baker didn't win by itself, training on the relationship between a research question and evidence for answering it produced a smaller model with stronger planning results. The separation makes evaluation inspectable, reviewers can ask whether a plan addressed criteria the paper ultimately proved important without handing the model the completed answer up front. New silicon at the entry level is more interesting than a renamed board. What exactly changed with NVIDIA's Jetson Oran Nano 2? NVIDIA says the new Edge AI board delivers about twice the throughput of the Jetson Oran Nano it replaces. It uses a new Oran system-on-chip built on the Ampere architecture, rather than recycling the prior chip for a refreshed product. The original Nano became a budget default for running inference near cameras, sensors, robots, and other devices. Doubling performance in that slot could raise the size or frequency of workloads those systems handle without sending every input to a remote data center. I want independent workload numbers before treating twice as fast as universal. NVIDIA hasn't published detailed per-workload benchmarks in the announcement, so that multiplier remains the company's headline claim. Real performance can vary with model type, numerical precision, memory pressure, power limits, and software optimization. Still, fresh silicon makes the claim plausible enough to matter. This isn't merely a software switch uncovering in used capacity on an old device. The entry-level performance boundary has moved, and that affects products whose power, price, and physical size rule out a larger Edge computer. So I'm skeptical of the universal multiplier, but not of the product direction. Existing teams will care about software continuity and whether their workloads need adjustment. New products gain more room before stepping up to a larger, hotter, and more expensive computer. Jetson or a Nano 2 doesn't erase edge constraints, it gives the lowest orantier substantially more room inside them. That can determine whether a prototype stays tethered to cloud inference or becomes a device capable of useful work on its own. That extra headroom matters most when a product lives inside a strict power and cooling envelope. It can spend new capacity on a larger model, a higher sensor rate, or parallel tasks instead of changing the entire hardware class. CodeBase memory MCP made the sharpest move, 41,596 stars, up 4,871 in 30 days, a 13.3% jump and release point 10.8 shipped in August. It indexes code into a persistent knowledge graph across 158 languages, offers submilisacent queries, and arrives as a dependency-free static binary. The project reports 99% lower token use. Nanobot, meanwhile, has 4-7,598 stars and release point 3, combining a self-hosted web interface with tools, memory, MCP connections, automation, chat apps, and multi-agent workflows. Those two fit together neatly. Nanobot supplies the personal agent environment, while code-based memory can give an agent a durable map of a repository instead of repeatedly stuffing source files into context. FastMCP completes the tooling side. It reached 27,470 stars and shipped 4.0 at the end of August, offering a Pythonic way to create MCP servers and clients. Nanobot grew by 1138 stars over 30 days, FastMCP added 481. Code-based memory's surge stands apart, suggesting persistent, low-token code intelligence has become particularly urgent as coding agents take on larger repositories. Nanobot offers the surrounding agent workspace, FastMCP makes new tool connections easier to create, and code-based memory helps those agents understand the software they're changing. Together, they cover the environment, tool interface, and durable code context without forcing every interaction to begin from an empty prompt. IBM Granite 4.28B is the marquee model edition, a dense 8 billion parameter reasoning model with a 131,000 token context window, available through the OpenRouter API. It handles text workloads spanning mathematics, code, multilingual dialogue, and multi-step agent tasks, with full and low-effort reasoning settings. Compact scale paired with unusually large input capacity distinguishes it from models that force long repositories or documents through aggressive compression. When 3.8 Flash Next is drawing local model interest with 4,561 likes and more than 207,000 downloads. It's an image and text-to-text conversational model, so it can interpret visual input alongside language and produce a textual response. The repository uses the Transformers and Safetancers ecosystem and advertises compatibility with hosted inference endpoints. That makes it relevant for document images, visual question answering, and assistants that need to discuss what appears in a picture without generating new imagery. The attention is real, but popularity doesn't answer deployment questions. Licensing, weight format, context length, published evaluations, and hardware requirements determine where it can actually run. Its appeal comes from joining visual understanding and conversation in an open model that people can place closer to their own data. PolyMill is building Japan's next-generation public AI infrastructure with open AI models and codecs, helping municipalities search administrative knowledge while accelerating software development. GitHub Copilot in VS Code, August 2026 releases tackles a connected coordination problem. Agent host and new session controls make parallel agent work, change review, and long conversations easier to organize. And understanding chat GPT work connects both ideas. Simon Willison describes a desktop choice between cloud and local execution, with local work able to access files and run programs on the computer. Whether an agent searches municipal records or changes software, where it runs determines which data, programs, and authority it can reach. For the sources and written details, look at the show notes at tobyonfitnesstech.com. Thanks for listening to Agent Stack Daily. We'll be back soon.