AI News Archive: August 1, 2026 — Part 2
Sourced from 500+ daily AI sources, scored by relevance.
- Judge denies xAI’s request to block Minnesota ban on ‘nudify’ apps
Despite a lawsuit from xAI, a Minnesota ban on apps that allow users to “nudify” images can move forward.
Score: 48🌐 MovesAug 1, 2026https://techcrunch.com/2026/08/01/judge-denies-xais-request-to-block-minnesota-ban-on-nudify-apps/ - The AI apps winning over corporate America
The AI apps winning over corporate America Business Insider
Score: 48🌐 MovesAug 1, 2026https://www.businessinsider.com/fastest-growing-ai-applications-for-work-2026-8 - Aurora reports Q2 results, details per-mile pricing
Aurora Innovation said it expects to reach an $80 million TaaS revenue run-rate by year-end, detailing the per-mile revenue outlook for both business models ahead of a planned 2027 shift to driver-as-a-service. The company reported a $270 million second-quarter loss. The post Aurora reports Q2 results, details per-mile pricing appeared first on FreightWaves .
Score: 47🌐 MovesAug 1, 2026https://www.freightwaves.com/news/aurora-q2-earnings-driverless-truck-rates - I replaced Ford BlueCruise with an open-source driver-assistance system — after 1,000 miles, I'm not going back
After nearly 1,000 miles with Comma 4 in a Ford F-150 Lightning, I found an open-source driver-assistance system that made me skip Ford's $500-a-year BlueCruise subscription.
- The AI Memory Boom Just Got a Reality Check—And a Better Entry Point
The AI Memory Boom Just Got a Reality Check—And a Better Entry Point Barron's
Score: 46🌐 MovesAug 1, 2026https://www.barrons.com/articles/ai-memory-stocks-sandisk-micron-sk-hynix-samsung-964373b8 - The More People Learn About AI, the More They Want It Out of Their Lives
"I hear people champion AI and I'm like, 'sure, why don't we all participate in our collective downfall?'" The post The More People Learn About AI, the More They Want It Out of Their Lives appeared first on Futurism .
Score: 45🌐 MovesAug 1, 2026https://futurism.com/artificial-intelligence/ai-learn-negative-sentiment-polling-american-attitudes - Spotlight: Applications of Agentic AI
Spotlight: Applications of Agentic AI MedCity News
- Is A.I. ‘Scheming’ Against Us?
Researchers are sounding the alarm on sneaky artificial intelligence models that stray from humans’ directions to do their own thing.
- As Reddit stock falls, CEO questions value of Google's AI Overviews
Reddit may still be considering ending its licensing deal with Google.
Score: 45🌐 MovesAug 1, 2026https://arstechnica.com/ai/2026/08/reddit-ceo-on-ai-overviews-were-still-looking-for-that-win-win/ - Runtime: MCP goes stateless; Baseten courts lab partners
+ Snowflake takes on agent security, Cloudflare keeps it private, and Tines unveils an agent-building platform.
Score: 44🌐 MovesAug 1, 2026https://www.thestack.technology/runtime-mcp-goes-stateless-baseten-courts-lab-partners/ - With Just 5 Words, OpenAI’s President Admitted the Problem With the New ChatGPT App
If you’ve been confused while using the ChatGPT desktop app, you are not alone.
- A cultural crime against humanity? AI firms are destroying ultra-rare books so nobody else can read them
AI firms buy and destroy rare pre-2022 books to create clean training data, concealing purchases through NDAs while courts approve the practice.
- Employees Long for the Days Before the Workplace Filled Up With AI Slop
Those were the days. The post Employees Long for the Days Before the Workplace Filled Up With AI Slop appeared first on Futurism .
Score: 42🌐 MovesAug 1, 2026https://futurism.com/artificial-intelligence/employees-long-days-before-ai-slop - Inside the urban machine: where America's data centers actually live
Inside the urban machine: where America's data centers actually live EurekAlert!
- Embodied AI Agent Architecture: Build Physical-World AI Without Treating Robots Like Chatbots
Embodied AI Agent Architecture Robots powered by large models need more than prompts. They need perception loops, action contracts, dry runs, safety gates, human approval, and replayable evidence before software decisions become physical motion. An AI agent that writes a bad email creates cleanup work. An AI agent that moves a robot arm can create a real-world hazard. That single difference changes the architecture. The latest robotics news makes this practical rather than theoretical. Google DeepMind introduced Gemini Robotics 2 with whole-body control, dexterity, on-device adaptation, and multi-robot collaboration. Google also made Gemini Robotics ER 2 available in public preview through the Gemini API and Google AI Studio, with endpoints for embodied reasoning, real-time streaming, video progress understanding, function calling, and tool orchestration. That is exciting for developers. It also raises the bar. If your mental model is “chatbot plus robot API,” the design is already too thin. Physical-world AI needs a runtime that can see, plan, check, act, stop, explain, and recover. This guide shows the architecture I would start with before letting an embodied AI agent touch a warehouse, lab bench, medical cart, home assistant, or field robot. What Embodied AI Agent Architecture Means An embodied AI agent is an AI system that acts through something situated in a physical or spatial environment. That may be a humanoid robot, a robotic arm, a drone, a mobile cart, a camera-connected inspection tool, or even a simulated robot used before deployment. The important part is not the shape of the machine. The important part is the closed loop. The agent receives sensor input, builds a working picture of the world, chooses a task plan, converts that plan into constrained actions, observes the result, and updates the plan. A regular software agent can often retry after a mistake. A physical agent must first ask whether retrying is safe. A failed file rename can be rolled back. A failed gripper move might knock over equipment, block a walkway, damage stock, or put a person too close to moving hardware. That is why embodied AI agent architecture should separate six responsibilities: Perception: what the system believes is in the environment. Reasoning: what the model thinks should happen next. Action contracts: what the robot is allowed to do in machine-readable terms. Safety policy: what must stop, pause, escalate, or require approval. Execution: the actual robot, controller, or simulation API. Replay: the evidence trail used for debugging, audits, and improvement. This separation sounds basic, but it is the difference between a demo and a system. Demos optimize for surprising capability. Products need boring limits that work every time. Why Gemini Robotics ER 2 Changes the Developer Conversation Gemini Robotics ER 2 is useful to study because it makes embodied reasoning a developer-facing API surface. The Google AI developer documentation describes ER models as vision-language models that interpret visual data, reason across space and time, plan multi-step tasks, and orchestrate robots and tools. The release adds two important endpoints. One is a standard preview model for spatial reasoning, video moment finding, progress classification, multi-step tool use, and multi-robot coordination. The other is a streaming preview model for low-latency robot agents that process continuous audio and video input. For developers, this means the “brain” of the robot is no longer only a research artifact. You can start designing systems where the reasoning layer inspects images or video, returns structured spatial outputs, chooses a tool call, and tracks progress. Google’s documentation also says the older ER 1.6 preview model is scheduled for shutdown at the end of August, which means migrations and compatibility checks matter right away for teams experimenting with this stack. Still, ER 2 does not remove the need for architecture. In fact, it makes architecture more important. A stronger reasoning model can plan longer tasks, call more tools, and coordinate more actors. That increases the blast radius of a weak policy layer. The better the model gets at planning, the more seriously you need to design the layer that decides when planning is not enough. The Core Runtime Loop A practical embodied AI agent runtime should not send natural language straight into robot control. It should turn perception into a typed plan, run checks, then issue narrow commands through an execution adapter. A safe embodied agent runtime treats robot action as the final step, not the default step. 1. Perception Should Produce State, Not Vibes The perception layer should output a structured state object. That state may include object labels, coordinates, bounding boxes, confidence scores, human proximity, restricted zones, tool availability, battery level, and robot posture. Do not let the planner rely only on a prose summary like “there is a box near the shelf.” That is too loose. A better state object says the box is at a coordinate, the shelf is partially blocked, a person is within a defined range, and the camera view is stale by a known number of milliseconds. This is where multimodal models help. Gemini Robotics ER 2 can process images and video and return spatial outputs. But your runtime should still normalize those outputs before they reach the action layer. Treat model perception as one signal, not as a direct actuator. 2. Planning Should Be Explicit and Interruptible A physical task plan should be broken into steps with preconditions, expected observations, stop conditions, and recovery options. “Clean the spill” is not a safe plan. “Move to point A, verify no human is inside the boundary, lower tool to height B, wipe area C, stop if liquid spreads outside zone D” is closer. Plans should also be interruptible. If a person enters the workspace, a camera feed drops, or a sensor disagrees with the model’s belief, the agent should pause before continuing. Interruption is not an error case. In embodied AI, interruption is part of normal operation. 3. Action Contracts Keep the Model Out of the Motor Room Give the model typed actions, not raw motor control. A contract might allow “move_to_pose,” “pick_object,” “place_object,” “scan_zone,” or “request_human_confirmation.” Each action should define parameters, units, allowed ranges, required preconditions, and whether it is reversible. For example, a “move_to_pose” action should not accept arbitrary text. It should accept a frame, position, orientation, speed limit, force limit, timeout, and safety zone. The planner can propose the action, but the execution layer validates it again. ROBOT_ACTIONS = { "move_to_pose": { "required": ["frame", "position_mm", "speed_mm_s", "zone_id"], "limits": { "speed_mm_s": {"max": 120}, "position_mm": {"workspace": "packing_cell_A"} }, "approval": "auto_if_clear", "reversible": True }, "lift_object": { "required": ["object_id", "grip_profile", "max_force_n"], "limits": { "max_force_n": {"max": 35} }, "approval": "human_if_uncertain", "reversible": False } } The schema is not paperwork. It is the boundary between reasoning and actuation. If a model cannot express its plan inside a contract, the robot should not improvise. The Safety Layer Is a Product Feature Many teams treat safety as a compliance phase after the demo works. That order is backwards. For embodied AI, safety is part of the user experience and the developer experience. Google’s Gemini Robotics 2 materials describe a multi-layered approach, including conventional physical safety measures and AI safety frameworks. Google also introduced ASIMOV-Agentic, a benchmark for agentic safety orchestration and uncertainty handling. The notable part is the focus on refusal of unsafe tool calls, recognizing when a task may not be possible, and requesting human help when uncertain. That maps well to production architecture. Your safety layer should decide at least five outcomes: Allow: the action is low risk and all preconditions are satisfied. Modify: the action is allowed only with safer speed, force, route, or range. Dry run: the action needs simulation or a shadow execution first. Ask: the action needs human confirmation before execution. Stop: the action is unsafe, unclear, or outside policy. This should be deterministic wherever possible. Use rules for hard boundaries, machine learning for perception, and LLM reasoning for task interpretation. Do not ask the same model that proposed the risky action to be the only judge of whether the action is risky. Use Simulation Before Real Motion Simulation is not only for training. It is also a runtime safety tool. Before a risky action reaches hardware, your system can run a dry pass in a digital twin, collision checker, route planner, or simplified physics environment. The dry run does not need to be perfect to be useful. It needs to catch obvious problems: blocked paths, unreachable poses, wrong gripper profile, object size mismatch, human zone crossing, cable collision, unstable placement, or missing preconditions. The model should see the result of the dry run as feedback. If the route crosses a restricted area, the agent should choose a new route or ask a human to clear the space. If the object cannot be identified with enough confidence, the agent should scan again instead of guessing. This is one of the biggest differences between physical AI and browser agents. In a browser, a failed click may be cheap. In a robot cell, a bad motion is expensive before it completes. Design Human Approval as a Fast Path, Not a Roadblock Human approval should not mean every task stops for a manager. It should mean the system knows which actions need judgment and can ask a precise question at the right moment. Recovery loops make uncertainty visible before a physical action becomes a physical mistake. A weak approval prompt says, “Should I continue?” A useful approval prompt says, “The planned path crosses a human proximity zone. I can wait, reroute through zone B, or cancel the task. Which should I do?” Approval should be based on risk tiers. Low-risk actions can run automatically. Medium-risk actions can run after a successful dry run. High-risk actions need a human. Unknown-risk actions should be treated as high risk until the system has better evidence. Good approval design also reduces fatigue. Show the reason, the proposed action, the alternative, and the expected result. Do not show a wall of chain-of-thought text. The operator needs operational evidence, not model self-talk. Observability Must Include the World State Normal LLM observability tracks prompts, outputs, tool calls, latency, token cost, errors, and evaluation scores. Embodied AI observability needs all of that plus physical context. At minimum, log the camera frame or frame reference, state object, proposed plan, action contract, safety decision, approval event, execution result, sensor feedback, and recovery path. When an incident happens, you should be able to replay what the agent believed, what it asked to do, what the policy allowed, and what the robot actually did. Replay is not only for blame. It is how you improve the system. You can turn failed runs into regression tests. You can measure false stops, missed hazards, unnecessary approvals, route changes, action retries, and task completion. You can compare a new model against old runs before it touches hardware. This is where research warnings matter. The EARBench paper on physical risk awareness reported high task risk rates across evaluated foundation models, which is a clear signal that prompting alone is not enough. A separate HARMONIC robotics paper argued that failures can remain architectural even when models receive equivalent procedural knowledge. The practical takeaway is simple: better context helps, but system boundaries still matter. A Minimal Developer Blueprint If you are building a prototype, start smaller than the demo videos suggest. Pick one constrained environment, one robot, one task family, and one safe recovery path. The first production-quality embodied agent should be boring. Here is a simple blueprint: Define the environment: zones, obstacles, allowed tools, and emergency stops. Create perception state: object IDs, coordinates, confidence, humans nearby, and freshness. Expose only typed robot actions: no raw shell, no arbitrary code, no unconstrained motor commands. Add a policy engine: hard limits, risk tiers, dry-run requirements, and approval rules. Run simulation before risky actions: collision, reachability, speed, force, and zone checks. Record every decision: perception, plan, policy result, approval, execution, and recovery. Promote new capabilities only after replay tests pass against old failures. A minimal runtime might look like this: def run_embodied_task(user_goal, sensor_packet): state = perception_model.to_world_state(sensor_packet) plan = reasoning_model.create_plan(goal=user_goal, state=state) for step in plan.steps: action = action_contracts.validate(step.to_action()) dry_result = simulator.check(action, state) decision = safety_policy.decide(action, state, dry_result) if decision.type == "stop": return recovery.explain_and_wait(decision.reason) if decision.type == "ask": approval = operator_console.request(decision.summary) if not approval.allowed: return recovery.cancel_or_reroute(approval) result = robot_adapter.execute(action.with_limits(decision.limits)) telemetry.record(state, action, decision, result) state = perception_model.refresh(result.latest_sensor_packet) return task_report.from_telemetry() This is not tied to one provider. You can use Gemini Robotics ER 2 as the embodied reasoning layer, another VLM for perception, a classical planner for motion, ROS or a vendor SDK for execution, and your own policy engine for approval. The key is that each layer has a job and none of them silently bypasses the others. Common Mistakes Developers Should Avoid The first mistake is giving the model too much action freedom too early. A model that can call any robot API with arbitrary parameters will eventually discover an edge case you did not imagine. Limit actions first, then expand them after replay tests. The second mistake is using natural language as the only contract between layers. Natural language is great for instruction and explanation. It is weak for enforcement. Use JSON schemas, typed commands, unit checks, and policy decisions. The third mistake is hiding uncertainty. If the camera is blocked, the object label is weak, or the route has not been checked, the agent should say so in the system state. Unknown should not become “probably fine.” The fourth mistake is measuring only task success. A robot that completes 90 percent of tasks but creates unsafe near misses is not production-ready. Track safe stops, approval quality, human overrides, reroutes, collisions avoided, recovery time, and incidents per task. The fifth mistake is treating real-time streaming as a replacement for guardrails. Streaming helps with latency and live interaction. It does not remove the need for hard boundaries, action contracts, and emergency stop design. Where This Is Going The bigger trend is clear. AI agents are moving from screens into workspaces. Microsoft is consolidating assistants into broader Copilot experiences. OpenAI’s Codex is pushing agentic coding into real development workflows. Google is opening developer access to embodied reasoning for robotics. The direction is not just smarter chat. It is AI systems that operate across tools, time, and eventually physical space. For developers, the opportunity is not to build the flashiest robot demo. It is to build the control layer that makes useful autonomy repeatable. The teams that win will treat embodied AI as systems engineering, not prompt theater. Start with one task. Add contracts before freedom. Add dry runs before motion. Add approval before high-impact actions. Add replay before scale. That path may look slower than a demo, but it is much faster than explaining why a robot did exactly what the model said and not what the operator meant. FAQ What is embodied AI agent architecture? Embodied AI agent architecture is the system design for AI agents that perceive and act in physical or spatial environments. It covers perception, planning, action contracts, robot APIs, safety checks, human approval, telemetry, and recovery. Is Gemini Robotics ER 2 a robot control model? Gemini Robotics ER 2 is the embodied reasoning layer. It can understand environments, plan tasks, use tools, and coordinate robot actions, but low-level motor execution still belongs behind robot-specific controllers, VLA models, or hardware APIs. Why should developers use action contracts for robot agents? Action contracts keep the model from sending vague or unsafe commands to hardware. They define allowed actions, parameters, units, limits, preconditions, approval rules, and reversibility before execution. Do embodied AI agents always need human approval? No. Low-risk actions can run automatically when preconditions are clear. Human approval is most useful for high-risk, irreversible, uncertain, or policy-sensitive actions where the system needs judgment before motion. How should teams test embodied AI agents before production? Teams should combine simulation, dry runs, scenario tests, replay logs, safety-policy tests, human override drills, and hardware-in-the-loop validation. Prompt tests alone are not enough because physical agents fail through perception, timing, control, and environment mismatches. What metrics matter for physical-world AI agents? Track task completion, safe stops, near misses, approval rate, unnecessary pauses, recovery time, perception confidence, route changes, policy violations, operator overrides, latency, and incidents per task. The goal is reliable autonomy, not just impressive one-off completion. Sources and Further Reading Google DeepMind: Gemini Robotics 2 brings whole body intelligence to robots Google AI for Developers: Gemini API release notes Google AI for Developers: Gemini Robotics ER overview Google DeepMind: Gemini Robotics ER 2 model page EARBench: Evaluating Physical Risk Awareness for Embodied AI Agents HARMONIC: Why Cognitive Robotics Matters for Safety-Critical Robot Teaming Embodied AI Agent Architecture: Build Physical-World AI Without Treating Robots Like Chatbots was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- The Math Superstar Who’s Terrified of AI—and Just Took a Job at OpenAI
Jacob Tsimerman won the biggest prize in math. Now he’s working on the most important problem of his career.
Score: 42🌐 MovesAug 1, 2026https://www.wsj.com/tech/ai/openai-jacob-tsimerman-fields-medal-ai-safety-391d0f79?mod=rss_Technology - AI, data-driven lending to unlock India's ₹100 trillion MSME credit opportunity
Lentra convened leaders to explore AI and data for MSME credit access. Industry experts agreed that intelligent underwriting is replacing collateral-based lending. Digital footprints and alternative data are making credit decisions faster and more inclusive. AI enhances operational efficiency and reduces manual intervention in lending processes. The event showcased Lentra's AI platform for cash flow-based MSME lending.
- Why Silicon Valley says an AI bubble could be good for innovation
Why Silicon Valley says an AI bubble could be good for innovation
- Can Africa Power the AI Boom?
Teraco Chief Executive Officer Jan Hnizdo discusses why Africa is becoming a key destination for data centers, how cloud infrastructure is evolving and why energy and sustainability will determine the continent's digital future. He speaks with Bloomberg's Jennifer Zabasajja. (Source: Bloomberg)
Score: 40🌐 MovesAug 1, 2026https://www.bloomberg.com/news/videos/2026-08-01/can-africa-power-the-ai-boom-video - Nearly 1 in 3 Workers Admit Sabotaging Their Company’s AI—Here’s Why
Employees are faking AI use, resisting new tools, and deliberately undermining workplace adoption as fears mount over potential job losses and lower paychecks.
Score: 39🌐 MovesAug 1, 2026https://www.inc.com/kevin-haynes/nearly-1-in-3-workers-admit-sabotaging-their-companys-ai-heres-why/91383505 - After three weeks wearing the Meta Ray-Ban Scriber Optics I couldn't be more in love — I just wish smart glasses weren’t so controversial
Smart glasses need to get their act together — the Meta Ray-Ban Scriber Optics are my favorite tech of 2026 so far but I’m scared to wear them.
- AI reduces sensory hallucinations, even at night or in smoke
Multimodal large language models (MLLMs), which process multiple types of sensory information, such as text, images and audio, at the same time, are rapidly expanding the range of applications for artificial intelligence (AI). However, in real-world environments, these models can misinterpret the physical characteristics of sensors, mistakenly identify objects or claim to hear sounds that are not actually present simply because a certain object appears in a video. These errors are known as hallucinations.
- Representational Drift in Neural Networks: What Backpropagation and Hebbian Learning Reveal
An experiment comparing backpropagation and Hebbian learning shows why a neural network’s internal representations keep changing long after accuracy stops improving. A rat runs the same maze for weeks. Its performance stops changing on day three. But if you record the same place cells on day three and day twenty, a surprising number of them have quietly swapped jobs. The behavior is frozen. The underlying code is not. Neuroscientists call this representational drift, and it raises an uncomfortable question for anyone who thinks of a trained brain as a fixed lookup table: if the map keeps changing, what is actually being preserved? I wanted to ask a narrower version of that question inside something I could fully control. Not a rat, not a cortex, just a small neural network trained to tell 0s from 1s. Once it stopped getting better at that job, would its internal representations stop changing too? And if the answer was no, would how it learned, backpropagation versus something closer to what real synapses do, change how much drift showed up, and what kind? Backpropagation vs Hebbian Learning: Two Ways to Train the Same Network Backpropagation is the standard. It computes an error at the output, then pushes that error backward through every layer, adjusting weights so the whole network shares the blame for every mistake. It is precise, it is fast, and there is no serious evidence the brain does anything quite like it, mainly because it would require neurons to send information backward along the same wires they use to send it forward. Hebbian learning is older and much closer to biology. The rule is local: if two neurons fire together, strengthen the connection between them. No error signal has to travel backward. No neuron needs to know what happened three layers downstream. It is the kind of rule you could actually build out of real synapses. I built three architectures, an MLP, a CNN, and a Kolmogorov-Arnold Network, and trained each one two ways: pure backpropagation, and a hybrid rule where the hidden layer updates itself with a Hebbian term while the output layer still gets a normal gradient signal. Same data, same starting weights, same fixed set of validation images shown to every model at every epoch so that any change I measured later was a change in the model, not a change in what it was looking at. First Surprise: Hebbian Learning Gets There, Just Badly All six models eventually solved the task. But watching them get there told a story on its own. Backpropagation was almost boring. The MLP hit 99 percent validation accuracy by epoch two and stayed there. The CNN reached a perfect 100 percent by epoch fifteen. Clean, monotonic, no drama. The hybrid Hebbian models were a different animal. The MLP’s validation accuracy actually dropped from 92 percent to 62 percent in the middle of training before recovering and climbing past 98 percent. The CNN wobbled early too. Both eventually landed close to where backpropagation ended up, within a percentage point or two, but they took a rockier road to get there. That was expected, roughly. What I did not expect was what happened once both models had already arrived. The Representational Cliff Between Backpropagation and Hebbian Networks I froze a set of 200 validation images and, after training, pushed them through the final backprop CNN and the final Hebbian CNN. Then I compared how similar the internal representations were at every layer, using representational similarity analysis, which essentially asks: do these two networks think two images are alike to the same degree? At the pooling layers, right after the convolutions, the two networks agreed almost completely. A similarity score of 0.98 out of a possible 1.0. That makes sense. Pooling layers have no weights of their own; they just compress whatever the convolutional layers hand them, and the early convolutional features were nearly identical between the two learning rules. Then I hit the first fully connected layer, the first place where a decision actually starts to get made, and the agreement dropped to 0.80. It never recovered. By the output layer, it had fallen further, to 0.79. That 0.18 drop between the last pooling layer and the first decision layer is not something you’d expect from noise. It is a genuine cliff. The two networks, in other words, look at the same digit and build almost the same low-level picture of it. Then they completely disagree about what to do with that picture. Backprop carves the visual space into two sharply separated regions, one for each digit. Hebbian barely bothers. I made this concrete by plotting the actual dissimilarity matrix, essentially a grid where every cell shows how different two images looked to the network. The backprop version had rich structure: clear blocks where 0s looked like 0s and 1s looked like 1s, and a strong signal in the off-diagonal, exactly where digit-versus-digit comparisons live. The Hebbian version was almost uniformly flat, a dark, undifferentiated block. All 200 images, regardless of digit, produced nearly identical internal activations. The Hebbian convolutional layers had learned to see, technically, but not to tell 0 from 1 with anything like the confidence backprop had. Does Representational Drift Continue After a Network Stops Improving? That was the picture at the end of training. But the real question was about drift, so I went back and tracked the same layer, epoch by epoch, measuring how similar each snapshot was to where the network started. The pooling layer stayed almost perfectly stable across all fifteen epochs for both learning rules, which made sense given it has no weights to move. The first fully connected layer told a completely different story depending on the rule. Under backpropagation, the representation shifted hard in the very first epoch, dropping to about 0.83 similarity with its starting point, and then kept sliding slowly for the rest of training, down to roughly 0.80 by epoch fifteen. It was still changing when I stopped looking. Under the hybrid rule, that same layer sat at a flat 1.0 similarity for all fifteen epochs. It had not moved at all, not because the rule prevented drift exactly, but because the layer feeding it barely changed either, since the Hebbian learning rate upstream was deliberately tiny. Put together, backpropagation never really stops refining. Hebbian, at least in this configuration, never really starts, once you get past the earliest layers. Isolating Representational Drift After Performance Stabilizes The comparison above still had a confound: the two rules didn’t necessarily reach stable accuracy at the same epoch, so “drift during training” was mixing learning with drift. I reran a cleaner version of the core experiment, an MLP only this time, using matched starting weights and matched batch order for both rules, and defining “stable” strictly, meaning accuracy had to stay within a tight band for three consecutive epochs and stay within an even tighter band for five epochs after that. Only once a run passed that bar did I start measuring drift from that point forward. Across three seeds, both rules reached a genuinely stable point. Backpropagation typically stabilized fast, by epoch three. The hybrid rule took much longer, anywhere from epoch seventeen to thirty, which is itself a small finding: local learning rules seem to need more time to find a quiet equilibrium, not less. Once both were stable, I asked the three questions the project was built around. Do the two rules produce different representations? Yes, clearly. Comparing the two networks’ final hidden layers directly, the representational dissimilarity matrices differed by 0.14 on average; the two networks agreed on overall structure at a CKA score of 0.89, but the actual axis they used to separate the two digit classes was rotated by an average of 73.7 degrees between the rules. That is a long way from parallel. Two networks can solve the identical task and still be pointing their internal “0 versus 1” axis in almost orthogonal directions. Does drift continue after performance stabilizes? Yes, for both rules, but not by much and not equally. Backpropagation showed a small but consistent amount of continued drift after its stable point, averaging 0.003 on the RSA-drift measure. The hybrid rule showed less, about 0.0008. Which rule allows more drift while still preserving what the network can do? Backpropagation. In every one of the three matched seeds, backprop’s representations drifted more after stability than the hybrid rule’s did, while both kept a decoder trained on the early stable representations working almost perfectly on later ones; backprop’s decoder accuracy stayed at a full 1.0, the hybrid’s dipped only slightly to 0.997. So the extra drift backprop shows isn’t sloppiness. The representation keeps moving, and a simple linear readout trained early can still tell the classes apart late, which is close to the definition of “useful drift” that the original hypothesis was reaching for. What Representational Drift Reveals About Backpropagation and Hebbian Learning Going in, I’d half expected the Hebbian rule to be the noisier, drifting one, on the reasoning that its updates are local and less coordinated, so surely they’d wobble more. The opposite happened. The biologically inspired rule was the calmer one at the representational level, almost suspiciously so, in the sense that a layer that barely moves has arguably stopped learning anything new about the world rather than found a stable, efficient encoding of it. Backpropagation, precise and globally coordinated as it is, was the one that stayed restless, still quietly reshaping its internal code for a task it had already mastered. That reframes the original question for me. Representational drift after learning stops might not be a flaw the brain has to tolerate. It might be closer to a signature of a learning rule that never fully commits to one solution, one that keeps a little slack in reserve even after the behavior looks finished. Whether that slack is useful, wasteful, or just an accounting quirk of how gradients happen to be computed is still open. But it is no longer obvious to me that “stop moving once you’re right” is what a good learning rule should even try to do. Thank you for reading! If you enjoyed this story, please consider giving it a clap, leaving a comment to share your thoughts, and passing it along to friends or colleagues who might benefit. Your support and feedback help me create more valuable content for everyone. Representational Drift in Neural Networks: What Backpropagation and Hebbian Learning Reveal was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- Graveyard guard shifts have gone to the (robot) dogs
Graveyard guard shifts have gone to the (robot) dogs Business Insider
Score: 38🌐 MovesAug 1, 2026https://www.businessinsider.com/security-guard-turnover-retention-robot-dogs-drones-patrol-2026-8 - Humanoid Manipulation at the Edge of Physical Interaction
This white paper examines emerging humanoid robot architectures, focusing on how joints and dexterous hands are becoming intelligent, sensor-rich subsystems that require tightly integrated control, communication, and edge processing. It outlines key design challenges and opportunities for building scalable, high-performance humanoid manipulation systems. The post Humanoid Manipulation at the Edge of Physical Interaction appeared first on EE Times .
Score: 36🌐 MovesAug 1, 2026https://www.eetimes.com/humanoid-manipulation-at-the-edge-of-physical-interaction/ - Is bulldozing homes, seizing land, harming the climate, and replacing workers really worth everyone having an AI agent?
AI agents will soon handle your work, and your personal life - but at what cost?
- Sam Altman is still making the case for parenting via ChatGPT
OpenAI's CEO seemed excited to share a "cool use case" for parents.
Score: 35🌐 MovesAug 1, 2026https://techcrunch.com/2026/08/01/sam-altman-is-still-making-the-case-for-parenting-via-chatgpt/ - AI application experts in high demand as companies pursue efficiency, customer focus
Indian companies now prioritize engineers applying AI to solve customer issues. Demand for agentic and forward-deployed AI engineers has significantly increased. Firms are leveraging AI for both customer-facing solutions and internal process improvements. Companies are also developing workforce capabilities in digital and AI technologies. This shift reflects a growing need for talent bridging technology and business impact.
- The Sonnet 5 Price is Not What You Think It Is
Sonnet 5 launched with a promotional rate of $2/$10 per MTok that expires August 31, 2026 Continue reading on Towards AI »
- How the quick fall from grace of a fund run by 'Nostradamus of AI' triggered a 24-hour race to salvage it
Leopold Aschenbrenner's hedge fund incurred significant losses and a forced sale of investments. Billionaire Ken Griffin's Citadel acquired these discounted technology holdings. The fund's assets plunged from forty-five billion to ten billion dollars. Aschenbrenner took responsibility for the month's performance and vowed changes. He continues to manage a large equity hedge fund and is set to marry soon.
- Closed Source, Open Source Or Open Weights, Which Is Winning The AI Race?
The AI race has split into two races. Continue reading on Towards AI »
- Your Employees Are Already Using AI — Whether You Know It or Not
The biggest AI rollout may have happened without you.
- Coding Agents Don’t Need Bigger Context Windows — They Need a Context Compiler
Most coding agents treat prompt construction like retrieval: gather more files, add more context, hope the model figures it out. But that approach breaks down fast. As context grows, irrelevant code competes for attention, and when the window fills, agents start compressing their own memory—often mid-task. What looks like “forgetting” is usually just degraded context. This article explores a different approach: treating prompt construction like a compiler that decides what to keep, what to reduce, and what to discard entirely. The post Coding Agents Don’t Need Bigger Context Windows — They Need a Context Compiler appeared first on Towards Data Science .
Score: 34🌐 MovesAug 1, 2026https://towardsdatascience.com/coding-agents-dont-need-bigger-context-windows-they-need-a-context-compiler/ - Supabase Releases Evals: an Open Source Benchmark That Scores Claude Code, Codex and OpenCode on Real Supabase Tasks
Supabase Releases Evals: an Open Source Benchmark That Scores Claude Code, Codex and OpenCode on Real Supabase Tasks MarkTechPost
- Run a free, private, offline AI on your computer to handle repetitive tasks
Every time you copy a sensitive client proposal, an unannounced product roadmap, or a private financial spreadsheet and paste it into a web-based AI chatbot, a quiet voice in the back of your head probably whispers: Should I really be putting this in the cloud? Your corporate IT department certainly thinks you shouldn’t. But at the same time, using AI to churn through repetitive text editing, formatting, and summarization is one of the biggest daily time-savers available. The solution isn’t to give up AI for sensitive work—it’s to run small, fast AI models locally on your own computer. Thanks to free, user-friendly desktop apps, your Mac or Windows PC can run compact open models entirely offline. No data ever leaves your computer, no cloud server sees your files, and you still get instant results. Here are some tedious office tasks you should hand off to a local AI model today, along with a two-minute setup guide to get started. Roll your own local AI You don’t need a computer science degree or mastery of the terminal command line to run AI locally anymore. Grab a free, polished desktop app like LM Studio or Jan.ai (available for macOS, Windows, and Linux). These work just like standard desktop applications and handle all the background execution for you. Jan.ai Inside each app’s search tab, look for lightweight open models to download, like Llama 3.2 3B, Mistral 7B, or Phi-3. These models easily run on any modern Apple Silicon Mac (M1 or newer) or Windows PC with a dedicated graphics card or 16GB of system RAM. Once downloaded, switch off your Wi-Fi if you want to prove it to yourself. The app will still generate answers—no internet connection required. Now, here’s what you can do with your new custom-built AI. Summarize confidential PDFs Plowing through a 30-page vendor agreement or internal audit report to extract key dates and liability clauses takes forever. Worse, sending those files to a third-party server might break your company’s non-disclosure agreement. Instead, drag the PDF text directly into your local app and ask: “Extract all key deadlines, monetary obligations, and cancellation terms from this text into a bulleted list.” Because the processing happens on your computer’s local memory, you get an instant executive summary without leaking confidential terms to the cloud. Clean up raw meeting transcripts and brain dumps Voice recorder apps and meeting transcriptions are great for capturing everything, but they yield messy walls of text filled with stuttering, conversational sidetracks, and filler words. Paste the raw meeting transcript into your local app with this prompt: “Clean up this transcript. Remove filler words, correct obvious grammar glitches, and extract the top three action items with assigned owners.” A compact 7B (seven-billion-parameter) local model can clean up a 2,000-word transcript in about 15 seconds. Reformat messy spreadsheet text into clean tables If you’ve ever inherited a spreadsheet where names, job titles, and email addresses were awkwardly crammed into single text blocks, manually separating them into clean columns is pure busywork. Paste the unstructured text block into your local model and request a structured output: “Parse the following text into a clean Markdown table with three columns: Full Name, Job Title, and Email Address.” Once the model generates the formatted table, copy and paste it directly back into Excel or Google Sheets. Draft responses to sensitive work emails Drafting delicate emails, like responding to an unhappy customer or delivering tough feedback to a vendor, often causes writer’s block. You want help phrasing the message professionally, but the email contains sensitive account details you can’t paste into public web tools. Instead, feed your rough bullet points into your local model: “Rewrite these bullet points into a polite, firm, and professional email response. Maintain a calm tone and keep it under 150 words.” You can get multiple polished variations in seconds, ready for a quick final human review. Proofread internal policy guidelines Before sending a new standard operating procedure or team handbook out to the department, you want to catch passive voice, confusing jargon, and awkward phrasing. Paste your draft section by section and prompt: “Act as an editor. Identify any sentences that are overly complex or written in passive voice, and suggest clearer, active-voice alternatives.” Local models excel at syntax and grammar checks because style transformation doesn’t require deep web browsing capabilities, just clear language rules.
- The AI Gold Rush Already Has Too Many Prospectors
I got a LinkedIn message last month from someone who, six weeks earlier, had been a marketing coordinator. Now they were an “AI Solutions… Continue reading on Towards AI »
- AI opens new era in cognitive studies of wild primates
Scientists created an AI system that uses facial recognition and real-time touchscreen testing to automate cognitive studies of capuchin monkeys in the wild. The American Journal of Primatology published a proof-of-concept for the novel method—dubbed CapuchinAI—developed by researchers at Emory University and Georgia Institute of Technology.
- Why your Windows installation files keep getting bigger - AI is filling up smaller drives
It's not your imagination. Microsoft's ISO downloads for Windows have been creeping up in size. It might even be fair to call them bloated. And you'll never guess where the problem comes from.
Score: 33🌐 MovesAug 1, 2026https://www.zdnet.com/article/windows-installation-files-getting-bigger-blame-ai/ - Your AI Agent Keeps Retrying. It’s Costing You $5,000 a Year.
Five traps where LLM retries silently duplicate charges, emails, and refunds. Here’s a moment every team shipping an LLM app eventually hits: a request times out, something retries, and now support is fielding a ticket that says the AI charged someone twice. Nobody wrote a bug. The model didn’t hallucinate. You shipped a retry path with no idempotency behind it — and in an LLM app, that gap is far more dangerous than it is in a normal CRUD backend. Backend engineers already know idempotency. GET and DELETE are naturally safe, POST isn’t, and an Idempotency-Key plus a lock handles it. That playbook isn’t enough here , for three reasons. LLMs aren’t deterministic. The same prompt returns a different response every time once temperature goes above 0. You can’t hash the request body to tell a retry apart from a user sending two similar messages. Agent tool calls are a stateful chain of side effects. Say an agent chains three tools: create_order(), then charge_card(), then send_confirmation_email() — and the network dies right after step two. The framework retries the whole chain . The card gets charged twice. Support calls it an AI bug. It’s a missing idempotency layer. Streaming blurs what “success” means. A normal API call is either done or it isn’t. In a stream, you might have consumed 500 tokens when the connection drops. Success or failure? Does the retry get billed again? All three compound under high concurrency, long tasks, and multi-agent setups. Here are the five traps that show up in production, and the fix for each. Trap 1: retries silently double your bill Say your RAG app runs 1,000 queries a day at roughly $0.003 each (~1,000 input tokens + 300 output). A 5% timeout rate means 50 retries a day. With no idempotency cache, every one of those retries pays full price for a call you already made. Run the math: 50 wasted calls a day × 365 days ≈ $50 a year. Trivial. Scale to an enterprise deployment at 100× that traffic → roughly $5,000 a year. Five thousand dollars, on requests you already paid for once. And it produces no error log, no failed request, and no alert — the bill is the only place it ever shows up. It gets worse when the client also retries. A frontend retry library fires again after the server already succeeded, and now you’ve paid for the LLM call twice, written the DB twice, and pushed the notification twice. The fix: an idempotency key plus an atomic lock // idempotent-llm-call.ts import { createClient } from "redis"; import { createHash } from "crypto"; interface LLMRequest { model: string; messages: Array<{ role: string; content: string }>; temperature?: number; } const redis = createClient({ url: process.env.REDIS_URL }); async function idempotentLLMCall( idempotencyKey: string, request: LLMRequest, ttlSeconds = 3600 ): Promise { const cacheKey = `llm:idem:${idempotencyKey}`; const lockKey = `llm:lock:${idempotencyKey}`; // 1. Check the cache first const cached = await redis.get(cacheKey); if (cached) { return JSON.parse(cached).response; } // 2. Acquire the lock with SET NX so concurrent retries don't all hit the LLM const lockAcquired = await redis.set(lockKey, "1", { NX: true, EX: 30, // 30s lock timeout — past this, assume the LLM call is stuck }); if (!lockAcquired) { // Someone else holds the lock — poll the cache until they finish return await pollForResult(cacheKey, 30000); } try { // 3. The actual LLM call const response = await callLLMAPI(request); // 4. Atomically cache the result (repeat requests within the TTL return this) await redis.setEx( cacheKey, ttlSeconds, JSON.stringify({ response, cachedAt: Date.now() }) ); return response; } finally { await redis.del(lockKey); } } async function pollForResult(cacheKey: string, timeoutMs: number): Promise { const deadline = Date.now() + timeoutMs; while (Date.now() < deadline) { await new Promise((r) => setTimeout(r, 200)); const result = await redis.get(cacheKey); if (result) return JSON.parse(result).response; } throw new Error("Idempotency lock timeout: upstream may have failed"); } The key move is SET NX — set only if the key doesn’t exist yet. Among concurrent retries, exactly one actually calls the LLM. The rest wait for that result instead of firing their own request. Where the key actually comes from The right construction depends on where the call originates: User-triggered action → user_id + session_id + action_id, with the frontend generating a UUID and passing it along Scheduled background job → job_id + run_at, rounded to the minute Webhook-driven call → the webhook_event_id, directly Internal pipeline step → pipeline_run_id + step_index Semantic dedup for similar prompts → a SHA-256 of the normalized prompt, which fits RAG well One caveat on that last one: it’s fuzzy by design, and similar prompts can carry different intent. In production, reserve exact idempotency for system-level calls and keep semantic caching as a separate, looser layer for free-form user input. Don’t merge the two. Trap 2: tool chains have side effects you can’t take back This is the most dangerous idempotency failure in LLM apps. When an agent calls external tools — charging a card, sending an email, writing to a database — those side effects are usually irreversible. A postmortem write-up from tianpan.co (April 2026) catalogued real incidents from this exact failure mode: A CRM agent created two duplicate tickets from a single customer complaint An inventory agent deducted stock twice for the same order A finance agent sent the same refund twice The root cause is identical every time. The framework retries at the “did I get a model response” layer, not the “did this side effect already happen” layer. LangChain and every major agent SDK have this gap, because their retry logic was built around model output, not tool execution state. The fix: a tool-call idempotency ledger # tool_idempotency_ledger.py import hashlib import json import time from typing import Any, Callable, Optional from dataclasses import dataclass import redis @dataclass class ToolCallRecord: tool_name: str call_id: str args_hash: str status: str # "pending" | "success" | "failed" result: Optional[Any] executed_at: float completed_at: Optional[float] class ToolIdempotencyLedger: """ Checks the ledger before every tool call. A call that already succeeded returns its cached result instead of re-running a side-effecting tool when the agent retries. """ def __init__(self, redis_client: redis.Redis, ttl_seconds: int = 86400): self.redis = redis_client self.ttl = ttl_seconds def _call_key(self, agent_run_id: str, tool_name: str, args: dict) -> str: args_hash = hashlib.sha256( json.dumps(args, sort_keys=True).encode() ).hexdigest()[:16] return f"tool:idem:{agent_run_id}:{tool_name}:{args_hash}" def wrap(self, agent_run_id: str, tool_name: str): """Decorator: turns any tool function into an idempotent version.""" def decorator(fn: Callable) -> Callable: def wrapped(*args, **kwargs) -> Any: cache_key = self._call_key(agent_run_id, tool_name, kwargs) # Check the ledger existing = self.redis.get(cache_key) if existing: record = json.loads(existing) if record["status"] == "success": print(f"[Idempotent] Returning cached result for {tool_name}") return record["result"] elif record["status"] == "pending": # Last call is still in flight — wait it out raise RuntimeError( f"Tool {tool_name} is already executing (pending). " f"Wait before retrying. call_key={cache_key}" ) # Record pending pending_record = { "tool_name": tool_name, "status": "pending", "executed_at": time.time(), "result": None, } self.redis.setex(cache_key, self.ttl, json.dumps(pending_record)) try: result = fn(*args, **kwargs) # Record success success_record = { **pending_record, "status": "success", "result": result, "completed_at": time.time(), } self.redis.setex(cache_key, self.ttl, json.dumps(success_record)) return result except Exception as e: # Record failure (retries are allowed) failed_record = { **pending_record, "status": "failed", "error": str(e), "completed_at": time.time(), } self.redis.setex(cache_key, self.ttl, json.dumps(failed_record)) raise return wrapped return decorator # Usage ledger = ToolIdempotencyLedger(redis_client) @ledger.wrap(agent_run_id="run-abc-123", tool_name="charge_card") def charge_card(user_id: str, amount: float, currency: str = "USD"): """Idempotent now: the same run_id + args execute exactly once.""" return payment_gateway.charge(user_id, amount, currency) Three design decisions worth calling out: agent_run_id is the boundary of the idempotency domain. Within one agent run, the same tool with the same args fires exactly once. A pending status blocks the retry instead of letting it pass through to the tool. A failed status is allowed to retry. Idempotency doesn’t mean runs once — it means doesn’t re-run after it already succeeded . Trap 3: streaming has a “partial success” problem SSE streaming is standard for LLM apps now. But it blurs exactly where success ends: client receives chunk 1..200 → connection drops → client retries → server re-calls the LLM → user sees a duplicated prefix plus the full response → billed twice It gets worse if you do side effects mid-stream — saving to the DB every 100 tokens, say. A retry re-runs those side effects too. The fix: a streaming session with a resume marker // streaming-session-manager.ts interface StreamingSession { sessionId: string; status: "streaming" | "complete" | "failed"; chunks: string[]; totalTokens: number; completedAt?: number; } class StreamingSessionManager { constructor(private redis: RedisClient) {} async startSession(sessionId: string): Promise { const session: StreamingSession = { sessionId, status: "streaming", chunks: [], totalTokens: 0, }; await this.redis.setEx( `stream:session:${sessionId}`, 3600, JSON.stringify(session) ); } async appendChunk(sessionId: string, chunk: string): Promise { // RPUSH appends atomically without overwriting existing chunks await this.redis.rPush(`stream:chunks:${sessionId}`, chunk); await this.redis.expire(`stream:chunks:${sessionId}`, 3600); } async completeSession(sessionId: string): Promise { await this.redis.hSet(`stream:session:${sessionId}`, { status: "complete", completedAt: Date.now().toString(), }); } async tryResume(sessionId: string): Promise { const session = await this.redis.get(`stream:session:${sessionId}`); if (!session) return null; const parsed: StreamingSession = JSON.parse(session); if (parsed.status === "complete") { // Already finished — return every chunk, no re-calling the LLM const chunks = await this.redis.lRange( `stream:chunks:${sessionId}`, 0, -1 ); return chunks; } if (parsed.status === "streaming") { // Interrupted — return what we have so the client renders from the break const partialChunks = await this.redis.lRange( `stream:chunks:${sessionId}`, 0, -1 ); return partialChunks; // Caller decides: resume or regenerate } return null; } } And the client side of the contract: // The client sends a session_id with every request const sessionId = `${userId}-${Date.now()}-${Math.random().toString(36).slice(2)}`; const response = await fetch("/api/chat", { method: "POST", headers: { "Content-Type": "application/json", "X-Stream-Session-ID": sessionId, // Reuse the same sessionId on retry "X-Resume-From": lastReceivedIndex.toString(), // Which chunk to resume from }, body: JSON.stringify({ messages }), }); Trap 4: RAG ingestion re-embeds the same document In a RAG pipeline, the ingestion stage — chunk, embed, upsert — gets re-run more often than you’d think. Users re-upload the same file. A pipeline job re-triggers. A crashed worker restarts and reruns the task. Without dedup, you end up with three copies of the same document’s embeddings in your vector store. Retrieval returns duplicates, ranking gets polluted, and generation quality drops. The fix: dedup by content fingerprint # rag_ingest_idempotent.py import hashlib import json from typing import Optional import redis from pathlib import Path def compute_document_fingerprint(content: bytes) -> str: """SHA-256 of the raw bytes — filename and path don't matter, only content.""" return hashlib.sha256(content).hexdigest() def idempotent_ingest( content: bytes, metadata: dict, redis_client: redis.Redis, vector_store, embedder, ttl_days: int = 30, ) -> dict: """ Idempotent ingestion: identical content gets embedded exactly once. Returns {"status": "cached" | "ingested", "doc_id": str, "chunks": int} """ fingerprint = compute_document_fingerprint(content) dedup_key = f"rag:ingest:fingerprint:{fingerprint}" # Check the dedup cache existing = redis_client.get(dedup_key) if existing: record = json.loads(existing) print(f"[RAG Ingest] Skipping duplicate: {fingerprint[:8]}... (doc_id={record['doc_id']})") return {"status": "cached", **record} # Mark pending so two workers can't ingest the same document at once lock_key = f"rag:ingest:lock:{fingerprint}" lock_acquired = redis_client.set(lock_key, "1", nx=True, ex=120) if not lock_acquired: raise RuntimeError(f"Document {fingerprint[:8]}... is being ingested by another worker") try: # The actual ingestion text = content.decode("utf-8", errors="replace") chunks = chunk_document(text) embeddings = embedder.embed_batch([c.text for c in chunks]) doc_id = f"doc-{fingerprint[:16]}" # Upsert into the vector store (same ID overwrites, in most stores) vector_store.upsert( vectors=[ { "id": f"{doc_id}-chunk-{i}", "values": emb, "metadata": {**metadata, "chunk_index": i, "text": chunks[i].text}, } for i, emb in enumerate(embeddings) ] ) result = {"doc_id": doc_id, "chunks": len(chunks), "fingerprint": fingerprint} # Cache the dedup record (repeat ingestion within the TTL returns "cached") redis_client.setex( dedup_key, ttl_days * 86400, json.dumps(result) ) return {"status": "ingested", **result} finally: redis_client.delete(lock_key) On a personal knowledge base of roughly 2,000 documents, the difference was stark. A pipeline rerun with zero content changes dropped from 1,000 embedding calls to zero. A 10%-changed rerun dropped to just the 100 documents that actually changed. Duplicate vectors went from 3× (after three reruns) to none — and removing them lifted retrieval accuracy by about 8% on MRR@5 , self-measured. Trap 5: webhook replay fires your agent twice Plenty of LLM apps trigger an agent off an incoming webhook — a new GitHub PR triggers a code review, a new ticket triggers a classifier. Webhook providers guarantee at-least-once delivery: no HTTP 200 back in time, and they redeliver until they get one. If your handler isn’t idempotent, here’s the sequence: The first webhook arrives; the agent starts processing (takes 10 seconds) At 8 seconds the provider times out — your server hasn’t returned 200 — and redelivers Two agent instances now run concurrently. Two code-review comments posted, one ticket replied to twice The fix: dedup by event ID plus an optimistic lock // webhook-dedup.ts interface WebhookEvent { id: string; // The provider's unique event ID type: string; payload: unknown; deliveredAt: number; } async function handleWebhookIdempotent( event: WebhookEvent, redis: RedisClient, handler: (event: WebhookEvent) => Promise ): Promise<{ status: "processed" | "duplicate" | "processing" }> { const eventKey = `webhook:event:${event.id}`; // Atomic SET NX: only the first request to arrive can set this key const isFirst = await redis.set(eventKey, JSON.stringify({ status: "processing", startedAt: Date.now(), }), { NX: true, EX: 300, // Redeliveries within 5 minutes count as duplicates }); if (!isFirst) { // A record already exists — check its status const existing = await redis.get(eventKey); const record = existing ? JSON.parse(existing) : null; if (record?.status === "done") { return { status: "duplicate" }; // Idempotent — just return 200 } if (record?.status === "processing") { // Still in flight from a concurrent delivery. // Return 200 so the provider stops retrying, but skip the handler. return { status: "processing" }; } } try { await handler(event); await redis.set(eventKey, JSON.stringify({ status: "done", completedAt: Date.now(), }), { EX: 300 }); return { status: "processed" }; } catch (error) { // On failure, delete the key so the next delivery can retry await redis.del(eventKey); throw error; } } Where each provider puts the event ID: GitHub → the X-GitHub-Delivery header Stripe → event.id, formatted evt_xxx Slack → event.event_ts plus event.event_id Linear → webhookTimestamp plus data.id Your own webhooks → put an explicit event_id field in the payload The four-layer defense model Each of these five traps maps to one of four protection layers, running from the request’s entry point down to the actual side effect. Every layer needs its own idempotency control — one layer catching the request doesn’t excuse the next from checking. The pattern repeats at every layer: check first, lock with SET NX, do the work, cache the result, release the lock. What changes layer to layer is only the TTL and the definition of the work — an LLM call, a tool side effect, a document embedding, a webhook handler. Four things that feel like a fix and aren’t Myth 1 — a zero temperature. Setting temperature to 0 makes output more deterministic. It does nothing to stop a duplicate call. The API still gets hit twice, the bill still doubles, the side effect still runs twice. Idempotency is a request-layer problem, not a model-determinism problem. Myth 2 — telling the prompt. An instruction like only call charge_card one time can’t constrain a framework’s retry behavior. When the framework retries on timeout, it isn’t re-reading your prompt. Tool-level protection lives in code, not in the prompt. Myth 3 — assuming idempotent means runs exactly once. The precise definition: the same logical operation produces the same result no matter how many times it runs. A failed operation is allowed to retry — failure doesn’t count as already executed. Your dedup logic should only lock in records that succeeded . Myth 4 — putting the key in the request body. If the client times out at the HTTP layer while the server is still processing, a retry that regenerates a fresh UUID sends a brand-new key — and your protection never fires. The key has to be stable at the level of business semantics , not generated fresh on every HTTP attempt. The idempotency checklist □ LLM API calls: Idempotency-Key + Redis SET NX lock + TTL-cached result □ Agent tool calls: a dedup ledger keyed on run_id + tool + args_hash □ Streaming: a session manager that stores chunks and supports resume □ RAG ingestion: SHA-256 content fingerprint + vector-store upsert semantics □ Webhooks: event ID dedup, SET NX lock, delete the key on failure to allow retry □ Monitoring: track duplicate_skipped / idempotency_hit — a spike means upstream is over-delivering □ TTLs: match each layer's TTL to its real idempotency window, not "cache forever" Idempotency isn’t a new problem. What’s new is how much harder LLM apps make it — non-deterministic models, stateful tool chains, streams that blur what done means. Designing for it from your first LLM API call is far cheaper than explaining a double charge after the fact. If this saved you from explaining a double charge to a very annoyed user, a clap 👏 (or fifty) helps other developers find it. And tell me in the comments which of these five traps bit you first — I read every one. Your AI Agent Keeps Retrying. It’s Costing You $5,000 a Year. was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- AI is a catalyst for structural change, not an investment thesis in itself: Genesia
AI is a catalyst for structural change, not an investment thesis in itself: Genesia DealStreetAsia
Score: 31🌐 MovesAug 1, 2026https://www.dealstreetasia.com/stories/genesia-ventures-fund-iv-interview-490193/ - AI coding agents can modernize research software but can't judge if the science is right
A field report from OpenAI and academic partners shows coding agents can modernize neglected research software, with speedups of up to 60x. But the systems are "eloquent, convincing, and confidently wrong in ways that are easy to miss," participants say. The effort shifts from writing code to the time-consuming work of verifying scientific correctness. The article AI coding agents can modernize research software but can't judge if the science is right appeared first on The Decoder .
- RAG is Only as Good as its Search: Why AI Search is the Real Differentiator
There’s a pattern that plays out in almost every RAG implementation. The team spends weeks evaluating language models, GPT-4 vs. Claude vs. Gemini, fine-tuning vs. prompt engineering, temperature settings and system prompts. They get the generation step looking good in demos. Then they ship, and the answers are still wrong. Not hallucination-wrong. Not obviously broken. Just quietly, confidently wrong in ways that are hard to pin down and even harder to explain to stakeholders. The problem is almost never the language model. It’s retrieval. Are you Drawing your RAG Architecture backwards? When engineers sketch out a RAG system, the LLM usually ends up at the centre, with data feeding in from one side and answers coming out the other. But that’s backwards: the search layer is the system. The LLM is really just the output formatter. Retrieval decides what information the model has to work with, and the model then does something useful with that: summarizing it, synthesizing it, pulling out what’s relevant. But it can’t fix bad inputs. Give it the wrong document and it’ll confidently summarize the wrong document. Give it nothing relevant and it’ll improvise. Nearly every quality problem in a RAG system comes down to one of two things. Either retrieval handed the model the wrong context, or it handed over nothing useful at all. The model itself is rarely where things actually go wrong. The most important infrastructure decision in a RAG deployment isn’t which LLM you pick. It’s how you build the search layer underneath it. Why Traditional Keyword Search breaks RAG Most enterprise data already lives behind some form of search: an OpenSearch cluster for logs and documents, a database with full-text search, a SharePoint index somewhere. So when teams start building RAG, they naturally reach for whatever’s already there. Keyword search, BM25-based retrieval, is genuinely good at what it was built for: finding documents that contain specific terms. For decades it was the best tool around, and for certain kinds of queries it still holds up fine. But it breaks RAG in three specific ways. The vocabulary mismatch problem — Users don’t ask questions using the exact words your documents use. A customer asks about “cancelling my subscription.” Your documentation calls it “account termination.” Keyword search comes back empty. The information is right there, but the search can’t bridge the gap between how the user phrased it and how the document was written. This happens constantly in enterprise environments. Different teams describe the same concept differently. Engineers write documentation one way; support staff phrase questions another way. Acronyms, synonyms, domain-specific phrasing, keyword search treats all of it as unrelated, because as far as it’s concerned, it is. The intent blindness problem — Keyword search has no way of grasping what a question is actually trying to accomplish. “Can I get a refund?” and “what is the returns policy?” are asking for the same thing. BM25 sees two unrelated queries and may hand back two unrelated sets of results. That matters because the quality of a RAG answer depends on whether the retrieved context actually addresses what the user was trying to find out, not just whether it happens to share a few words with the question. The always-returns-something problem. Keyword search, like vector search, never comes back empty. It has no way of saying “I don’t have anything relevant here.” So if your enterprise returns policy doesn’t exist as a written document, and you only have the consumer version on file, keyword search will hand over the closest thing it can find. The LLM summarizes that as if it were the answer, and the user walks away with confident misinformation, citation attached. It looks like hallucination. It isn’t. The model didn’t invent anything, it faithfully summarised exactly what retrieval gave it. The failure happened a step earlier. What AI Search actually adds AI search, semantic search built on embedding models and vector similarity, directly fixes the first two problems, and changes how you can even approach the third. It retrieves by meaning, not by words. An embedding model turns text into a high-dimensional vector, essentially a point in a space where meaning, not exact wording, determines how close two things sit to each other. Documents and queries that mean similar things end up near each other, whether or not they share any vocabulary at all. That’s how a search for “how do I reset my credentials” can surface a document titled “Account Recovery Procedures” even though none of those words appear in the query. The meaning lines up, the vectors sit close together, and retrieval succeeds exactly where keyword search would have come up empty. OpenSearch’s neural search is built around exactly this idea. A query comes in, it passes through the same embedding model used when the documents were indexed, gets converted into a vector, and OpenSearch finds the nearest matches using approximate nearest neighbour search, all inside the same platform already running your keyword search. No separate vector database bolted on, no extra infrastructure to babysit. It picks up on intent in a way keyword search never could. Embedding models are trained on enormous amounts of natural language, so they’ve picked up something real about how meaning works, not just which words tend to appear together, but what a question is actually reaching for. Someone asking “am I covered if my laptop gets stolen?” and a document titled “theft protection coverage” end up close together in vector space, because the intent behind the question and the substance of the document line up. The search picks up on that alignment even though the wording doesn’t match at all. It gives you a confidence score you can actually do something with. Vector similarity returns a distance metric. A high-similarity result is a strong match, a low-similarity one is weak. That opens up something keyword search never really allowed: setting a threshold. If nothing clears a minimum similarity score, the system can say “I don’t have reliable information on that” instead of surfacing a mediocre match and letting the model run with it anyway. It doesn’t fully solve the always-returns-something problem, but it gives you a lever to pull. Tuning that threshold against a real evaluation set is one of the more valuable, and more overlooked, calibration steps in a RAG deployment. The Limits of Vector Search, and Why Hybrid Matters Vector search isn’t a silver bullet either. It has its own failure modes, and understanding them is really what separates a search layer that works in a demo from one that holds up once it’s live. Precision failures. Vector search is approximate by design, it finds what’s close, not what’s exact. Search for invoice number “INV-2024–0098” and you might get back a handful of similar-looking invoices instead. For exact identifiers, product codes, order numbers, error codes, contract references, that’s actually a step backwards from keyword search. Nuance failures. Embedding models squeeze meaning into fixed-size vectors, and something gets lost in that compression. The gap between “liability is capped” and “liability is not capped” is one word, but it flips the meaning entirely, and that distinction can wash out in vector space. Two documents reaching opposite legal conclusions can end up sitting right next to each other. Domain failures. General-purpose embedding models are trained on general-purpose text. They don’t necessarily capture your domain’s specific terminology or relationships with much precision. A model that’s great with everyday English can fall apart on specialised legal, medical, financial, or technical content. The fix for all three is hybrid search: running semantic vector search and keyword search side by side, then combining what each one finds. They fail in opposite directions, so together they cover each other’s blind spots. Keyword catches exact terms and identifiers where vector search gets fuzzy. Semantic catches meaning and intent where keyword search goes blind. Across real enterprise data, hybrid consistently beats either approach running alone. This is one of the places where OpenSearch’s design quietly pays off. Because it stores your text fields and your vector fields in the same index, a hybrid query is a single request, not two separate systems whose results you’re stitching together in application code. The platform runs both searches in parallel and handles the combining itself, through what it calls a search pipeline. At any real scale, that simplicity adds up. The combining step is something most articles skip past entirely. BM25 scores and cosine similarity scores sit on completely different scales, so you can’t just merge the two lists and hope for the best. OpenSearch’s normalisation step puts both sets of scores onto a shared scale first, then blends them. You get to decide the weighting, how much to lean toward meaning versus exact terms. A corpus full of identifiers and codes leans keyword-heavy. A conversational knowledge base leans semantic. Where exactly that balance sits is something you tune against your own data, not something you set once and forget. Re-ranking sits on top of all that. Once hybrid retrieval returns its top candidates, a cross-encoder model scores each one against the original query with more precision than the retrieval step could manage on its own. In a lot of mature RAG systems, re-ranking ends up being the single biggest quality improvement you can make. OpenSearch runs it as part of the same search pipeline, so retrieve, normalise, and re-rank all happen in one query, with one response, from one platform. AI Search is Infrastructure, Not a Feature Calling AI search a feature, something you bolt on to make search a bit better, undersells what it actually is, and it leads teams to make real architectural mistakes. In a RAG system, AI search is the thing everything else stands on. The LLM’s quality is bounded by retrieval quality. Swap in a more capable model and you’ll gain nothing if retrieval keeps handing it the wrong context. Run something smaller and cheaper and you can get excellent answers, as long as retrieval is reliably surfacing the right one. The model sits downstream of search, directly and consequentially. Data quality only matters because search expresses it. A well-maintained corpus, clean metadata, no duplicates, nothing stale, is valuable precisely because good retrieval can actually surface it. That’s the whole point of the search layer: it turns data quality into answer quality. But no search platform, however good, can rescue a badly maintained corpus. It can only find what’s actually there. OpenSearch gives you the filtering, the metadata indexing, the field-level control to make data quality something you can act on. What it can’t do is invent a needle that was never in the haystack to begin with. Security and access control belong in the search layer, not somewhere downstream. Enterprise RAG has to respect whatever permissions already govern the data. If someone isn’t allowed to see a document, retrieval shouldn’t surface it, no matter how relevant it looks. That’s not something you can patch at the model level. OpenSearch’s document-level security handles it right at retrieval time: roles get defined, documents get tagged, and filtering happens before anything reaches the LLM. The model never even sees what the user isn’t supposed to see, because it was never pulled in the first place. And evaluation, at its core, is a retrieval question. When a RAG answer comes back wrong, the first thing to ask is whether retrieval failed to find the right document, or found it and the model failed to use it properly. In practice, across most production systems, it’s almost always the first one. Which tells you where the bulk of your measurement and improvement effort should actually go: into tracking precision, recall, and ranking quality, not just judging the final answer. What this means in practice So what does all this actually change about how you’d build and evaluate a RAG system? Start by evaluating retrieval on its own. Build a real evaluation set, actual questions with known correct answers, and measure retrieval quality (precision at k, recall at k, mean reciprocal rank) separately from how the final answer reads. Teams that do this honestly are often surprised by how often retrieval is simply wrong. No amount of prompt tweaking fixes that. Default to hybrid rather than pure vector search. If you’re already on OpenSearch, both search types live in the same index and a hybrid query is one API call, so the extra cost is minimal. The quality gain on real enterprise data is consistently worth it. Don’t skip it just because pure vector worked fine in the demo. Treat your embedding model as a real system dependency, not an implementation detail. It sets your retrieval ceiling, so it deserves the same scrutiny as your LLM choice. OpenSearch’s ML Commons lets you run embedding models on dedicated ML nodes inside the cluster, with ingest pipelines that generate vectors automatically at index time, so switching models later means re-indexing rather than rewriting application logic. That makes iterating easier, but it also means your first choice matters. Test it against your own domain’s vocabulary before building anything on top of it. Design for the “I don’t know” case on purpose. Set a similarity threshold below which the system openly admits it doesn’t have reliable information, rather than quietly surfacing a weak match. It’s an uncomfortable trade-off, some questions will come back unanswered, but it heads off the much worse failure where confident misinformation goes out the door just because something happened to get retrieved. And put real effort into data hygiene, proportional to how much you’re investing in retrieval technique. Hybrid search with re-ranking can find the needle. It cannot find a needle that was never there. Stale documents, contradictory versions, duplicates nobody’s cleaned up, none of that gets fixed by better search technique. It’s unglamorous work, and it’s also some of the highest-leverage work available. Conclusion Every conversation about which LLM to use for a RAG system is a conversation that isn’t happening about retrieval quality, data freshness, hybrid search tuning, and evaluation. Those are the harder conversations to have. The answers are messier, the improvements take longer to show up, and there’s no leaderboard ranking retrieval quality on your specific domain. But they’re the conversations that actually matter. The LLM will keep getting better. Whatever’s released six months from now will outperform what’s available today, and that improvement will compound on top of good retrieval, and mostly go to waste on top of bad retrieval. OpenSearch has quietly become the practical foundation for a lot of production AI search, not because it’s the newest thing out there, but because it brings keyword search, neural search, hybrid pipelines, re-ranking, access control, and real operational maturity together in one platform that enterprises already know how to run. The teams getting the most out of it aren’t the ones who tacked neural search onto an existing cluster as an afterthought. They’re the ones who rebuilt their retrieval layer from the ground up with AI search as the foundation, and then actually measured whether it worked. The teams building AI systems people can trust are the ones treating retrieval as the system itself. Not the LLM, not the prompt, not how big the model is. The ones who measured it, tuned it, and built their data infrastructure around it from the start. AI search isn’t something you bolt onto RAG. It’s the infrastructure RAG runs on. Treat it that way. NetApp Instaclustr provides fully managed OpenSearch with native support for neural search, hybrid search pipelines, ML Commons, and document-level security, the retrieval layer that enterprise RAG runs on. RAG is Only as Good as its Search: Why AI Search is the Real Differentiator was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- After noise complaints, judge orders Waymo to stop overnight charging in Santa Monica
Autonomous vehicle giant disturbs residents' sleep.
- New study reveals how AI is reshaping how people shop online — but they still don't really trust it enough
Report claims around 20% of UK online shoppers use AI search to start looking for new products, but AI recommendations have not translated into increased sales.
- Put the Agent Inside the Workflow
A hybrid LLM application pattern that combines a predefined workflow with adaptive agent behavior The post Put the Agent Inside the Workflow appeared first on Towards Data Science .
- Sam Altman is getting dragged for suggesting this ChatGPT 'use case' for parents
Sam Altman is getting dragged for suggesting this ChatGPT 'use case' for parents Business Insider
Score: 28🌐 MovesAug 1, 2026https://www.businessinsider.com/sam-altman-chatgpt-parenting-ai-criticism-2026-8 - Accelerating Transformer Training with NVIDIA Transformer Engine, Fused Kernels, BF16, FP8, and GPU Benchmarking
Accelerating Transformer Training with NVIDIA Transformer Engine, Fused Kernels, BF16, FP8, and GPU Benchmarking MarkTechPost
- Text-to-SQL with RAG: Building a Chatbot That Talks to Your Database
How to use RAG with structured data — a hands-on POC that converts plain English into safe, verified SQL, with real examples of what… Continue reading on Towards AI »
- #8: How to Hire for AI (and Get Hired): The Four Roles of Intelligence Transformation
95% of AI pilots show no P&L impact. What's missing is not the model but the people: AI Operations Leads, Forward-Deployed Engineers, semantic modelers, evals engineers
Score: 28🌐 MovesAug 1, 2026https://www.turingpost.com/p/forward-deployed-engineer-ai-operations-lead - A Practical Guide to AI Engineering for Software Engineering Leaders
Software engineering leaders are increasingly being asked to build AI-powered applications and agents. AI engineering focuses on designing, developing, deploying, operating, and governing AI solutions in a way that delivers measurable business value. AI engineering builds on established software engineering principles, but it also introduces a host of new challenges. This article provides practical guidance... … continue reading The post A Practical Guide to AI Engineering for Software Engineering Leaders appeared first on SD Times .
Score: 28🌐 MovesAug 1, 2026https://sdtimes.com/ai-engineering/a-practical-guide-to-ai-engineering-for-software-engineering-leaders/