AI News Archive: June 25, 2026 — Part 10
Sourced from 500+ daily AI sources, scored by relevance.
- Try these 3 Google AI tools to help find your next job.
Job hunting can be a slog. But with a few Google AI tools, you can simplify the process from start to finish.Career Dreamer: The first step in landing a job is finding o…
Score: 23🌐 MovesJun 25, 2026https://blog.google/products-and-platforms/products/gemini/find-job-with-google-ai-tools/ - Rovo MCP, Teamwork Graph CLI, Rovo Dev CLI: sorting out the name game
Rovo MCP, Teamwork Graph CLI, Rovo Dev CLI: sorting out the name game Atlassian Community
- LinqAlpha Wins Best AI Solution at the 2026 Hedge Fund Services Awards
LinqAlpha Wins Best AI Solution at the 2026 Hedge Fund Services Awards The Straits Times
- Domus Next Launches SuperNori: The First Proactive Family AI Agent That Runs Your Family With You
Domus Next Launches SuperNori: The First Proactive Family AI Agent That Runs Your Family With You markets.businessinsider.com
- Governor Landry’s Data Center Order is Too Little, Too Late
After spending years as one of the nation’s biggest data center supporters, Louisiana Gov. Jeff Landry has issued a hollow executive order calling for guardrails that would do far too little to protect Louisianans from the impacts of the very centers he has been courting. In response, Sierra Club issued the ... [continued] The post Governor Landry’s Data Center Order is Too Little, Too Late appeared first on CleanTechnica .
Score: 22🌐 MovesJun 25, 2026https://cleantechnica.com/2026/06/25/governor-landrys-data-center-order-is-too-little-too-late/ - REBL Labs Opens Early Access to Aimee, Its AI Content Writer Built for SEO, AI Visibility, and Content Performance
REBL Labs Opens Early Access to Aimee, Its AI Content Writer Built for SEO, AI Visibility, and Content Performance azcentral.com and The Arizona Republic
- Tame Your AI Monsters: Claude Edition 🛡️
Unleash agents, not risk
- Rovo Agent vs Jira Automation: When to Use Which
Rovo Agent vs Jira Automation: When to Use Which Atlassian Community
- The AI web browser that remembers your logins
An AI-powered browser that automatically logs you into sites, enhancing security and convenience.
Score: 21🌐 MovesJun 25, 2026https://www.superhuman.ai/p/the-ai-web-browser-that-remembers-your-logins - Saying ‘Please’ and ‘Thank You’ to AI Sounds Crazy. It Might Actually Work.
Saying ‘Please’ and ‘Thank You’ to AI Sounds Crazy. It Might Actually Work. entrepreneur.com
Score: 21🌐 MovesJun 25, 2026https://www.entrepreneur.com/business-news/saying-please-and-thank-you-to-ai-might-actually-work - Meet DeepL: Bringing a builder mentality to marketing, with pride
DeepL showcases how its team leverages authenticity and cultural nuance to scale global marketing workflows and foster inclusive teams.
- Medical Care Technologies, Inc. (OTC Pink:MDCE) Showcases Diversified Technology Portfolio with Newly Launched Platforms Across AI Health, Enterprise Vision Solutions, and Collectibles Markets
Medical Care Technologies, Inc. (OTC Pink:MDCE) Showcases Diversified Technology Portfolio with Newly Launched Platforms Across AI Health, Enterprise Vision Solutions, and Collectibles Markets USA Today
- How Maison Roboto Invented Fashion for Humanoid Robots
How Maison Roboto Invented Fashion for Humanoid Robots TIME Africa
Score: 20🌐 MovesJun 25, 2026https://africa.time.com/art/how-maison-roboto-invented-fashion-for-humanoid-robots/ - Qualcomm vs Nvidia and drones vs dogs
The inside story on the Asia tech trends that matter, from Nikkei Asia and the Financial Times
- SPAC Deals Seen as Key Path to Public Market in Data Center Boom
The rebound in blank-check companies is proving to be a useful route to public markets for companies involved in the artificial intelligence-data center build-out, said Betsy Cohen, a veteran of dealmaking in special purpose acquisition companies (SPAC). The Cohen Circle …
- Question Answering in Knowledge Networks — Capacity Bounds and Scheduling
Question Answering in Knowledge Networks — Capacity Bounds and Scheduling Carnegie Mellon University
- Build Engaging Recruitment Campaigns for Manufacturing Companies Using AI Avatar Employee Ambassadors
In the last decade, the method of recruiting potential candidates by manufacturers has drastically changed. It is not just a consideration for job functions and benefits but also for workplace culture, opportunities for advancement, “team environment,” and the daily experience of working in a specific position. In parallel, companies find it difficult to produce recruitment [...] The post Build Engaging Recruitment Campaigns for Manufacturing Companies Using AI Avatar Employee Ambassadors appeared first on Disrupt Africa .
- AI & Robotics Venture Day - Swartz Center for Entrepreneurship
AI & Robotics Venture Day - Swartz Center for Entrepreneurship Carnegie Mellon University
Score: 19🌐 MovesJun 25, 2026https://www.cmu.edu/swartz-center-for-entrepreneurship/events-new/cmu-startup-week/ai-robotics-venture-day.html - Parcel Tracker Introduces Improved AI-Powered Name Recognition in Its Evolution to an Agent-Based Logistics Platform
Parcel Tracker Introduces Improved AI-Powered Name Recognition in Its Evolution to an Agent-Based Logistics Platform USA Today
- I connected NotebookLM and Claude — and built the ultimate AI research assistant
I connected NotebookLM and Claude — and built the ultimate AI research assistant Tom's Guide
Score: 19🌐 MovesJun 25, 2026https://www.tomsguide.com/ai/i-connected-notebooklm-and-claude-and-built-the-ultimate-ai-research-assistant - June 2026: LangChain Newsletter
Monthly roundup of LangChain news and updates.
- Evaluate Recognized for Artificial Intelligence Innovation in 9th Annual AI Breakthrough Awards Program
Evaluate Recognized for Artificial Intelligence Innovation in 9th Annual AI Breakthrough Awards Program Toronto Star
- PayStubs Launches AI Pay Stub Generator to Simplify Income Documentation for Gig and Self-Employed Workers
PayStubs Launches AI Pay Stub Generator to Simplify Income Documentation for Gig and Self-Employed Workers USA Today
- Will Rovo Replace ScriptRunner? My Take After 3 Months
Will Rovo Replace ScriptRunner? My Take After 3 Months Atlassian Community
- ET Most Innovative AI Product Awards 2026 spotlight enterprise AI solutions redefining business performance
As enterprises scale AI adoption, innovation is moving beyond customer-facing applications. From finance, operations, tax, and legal functions to AI infrastructure and developer tools, breakthrough solutions are delivering measurable business outcomes, improving decision-making, enhancing efficiency, and enabling enterprise-wide transformation.
- I used ChatGPT to audit my subscriptions — these prompts helped me find nearly $2,000 a year in recurring charges
I used ChatGPT to audit my subscriptions — these prompts helped me find nearly $2,000 a year in recurring charges Tom's Guide
- Vicfuse Introduces UL Class Fuse Series for Modern AI Infrastructure and Industrial Protection
Vicfuse introduces its UL Class fuse series, an industrial circuit-protection portfolio designed for AC and DC applications. The post Vicfuse Introduces UL Class Fuse Series for Modern AI Infrastructure and Industrial Protection appeared first on EE Times .
- Our latest Google Finance upgrades, including a new app
The Google Finance logo, surrounded by elements of the user interface
Score: 17🌐 MovesJun 25, 2026https://blog.google/products-and-platforms/products/search/google-finance-updates-june-2026/ - This free Pixel app is the reason I canceled my AI note-taking subscription
I stopped paying for AI meeting notes thanks to Pixel Recorder.
Score: 17🌐 MovesJun 25, 2026https://www.androidauthority.com/canceled-ai-note-taking-subscription-after-using-pixel-recorder-3676129/ - Goody Launches a Gifting MCP, Bringing Business Gifting Into the AI Stack
Goody Launches a Gifting MCP, Bringing Business Gifting Into the AI Stack azcentral.com and The Arizona Republic
- I wanted Google’s secret AI dictation app to replace Wispr Flow, but it couldn’t
Free, offline, and frustratingly unreliable at times.
Score: 16🌐 MovesJun 25, 2026https://www.androidauthority.com/google-ai-edge-eloquent-vs-wispr-flow-3678620/ - Until June 29, get Claude, Gemini, and ChatGPT for life for $70
1min.AI is an AI platform that gives you lifetime access to ChatGPT, Gemini, and more for $70
Score: 16🌐 MovesJun 25, 2026https://mashable.com/tech/june-25-1minai-advanced-business-plan-lifetime-subscription - Grizzly Media Co Launches AI Search Optimization for Trades
Grizzly Media Co Launches AI Search Optimization for Trades azcentral.com and The Arizona Republic
Score: 16🌐 MovesJun 25, 2026https://www.azcentral.com/press-release/story/88105/grizzly-media-co-launches-ai-search-optimization-for-trades/ - The Attribution Gap: Tracking Marketplace Leads with Rovo + Forge
The Attribution Gap: Tracking Marketplace Leads with Rovo + Forge Atlassian Community
- I'm seriously allergic to poison ivy — this Gemini feature helps me when I'm weeding
I'm seriously allergic to poison ivy — this Gemini feature helps me when I'm weeding Tom's Guide
- EDMO Launches Email Doc Extractor to Automate Admissions Document Processing
EDMO Launches Email Doc Extractor to Automate Admissions Document Processing azcentral.com and The Arizona Republic
- 44 Seconds: How an AI Removed a Customer’s Fear and Recovered a £1,099 Sale
A real-time cognitive classifier built with XGBoost, FastAPI, and Node.js — deployed on SAP Commerce Cloud, extensible to any platform Source: Image by the author. Arjun is 33. Software developer. Laptop shopping for work. He visited the same product page three times over six days. Monday. Thursday. Sunday. He never bought. The website had absolutely no idea he had been there before. Every time, it showed him the same page. 47 laptop configurations. 342 reviews. A comparison table. A plain “Add to cart” button. On his third visit, our system watched him for 90 seconds. Not who he was. Not his name, age, or purchase history. Just what he did . He hovered on the battery specification for over 14 seconds. He scrolled back up to re-read the same section six times. He spent 48 seconds reading two-star reviews — specifically the ones mentioning battery life. He had visited three times and never once clicked “Add to cart.” He was not overwhelmed. He was not undecided. He had one specific, unresolved fear. The AI classified him. Four possible outcomes: Analytical → expand specs, show comparison data, use data-heavy social proof Overwhelmed → simplify the page, collapse to three options, hide filters Hesitating → address the specific fear directly, surface the right trust signal, change the CTA Default → confidence too low, show the standard page unchanged Arjun’s result: Hesitating. Confidence: 84%. It moved the battery guarantee to the top of the page. It surfaced five verified reviews from software developers praising battery life. It changed the button to say: “Add to cart — 30-day battery guarantee.” 44 seconds later, Arjun bought a £1,099 laptop. Six days. Three visits. Eight minutes of engagement. One unresolved fear. 62 milliseconds to remove it. A real-time behavioural classifier detects which of four cognitive modes a buyer is in — analytical, overwhelmed, hesitating, or default — and restructures the page experience accordingly. XGBoost. Under 50ms. $0.00056 per call. Deployed on SAP Commerce Cloud. Built in one week across ten phases. This article walks through every architectural decision and every line of code that made it possible. The Problem Nobody in E-Commerce Is Solving The industry has spent a decade building recommendation engines. They are genuinely impressive. Amazon’s recommendation engine drives an estimated 35% of its revenue . Netflix saves approximately $1 billion per year by reducing churn through recommendations. But they all solve the same problem — what to show. 70% of commerce website visitors leave without buying . Many of them know exactly what they want. They are not leaving because they saw the wrong product. They are leaving because the page was designed for a different kind of buyer. Source: Image by the author. The gap is consistent across every major tool — Dynamic Yield, Monetate, Optimizely, and Adobe Target. None detect what cognitive mode a buyer is in and restructure the page experience accordingly, in real time, for each session. That is the gap CCO closes. The Three Buyer Modes CCO Detects Every visitor is classified into one of four states. There are three active modes. One is a fallback. Source: Image by the author. The classifier does not lock a mode in. It updates every two seconds as new signals arrive. If Arjun had shifted from hesitating to analytical mid-session, the page would have responded accordingly. What We Built — Ten Phases in One Week Source: Image by the author. The Technical Architecture Browser └── cco-tracker.js (8KB · any website · collects 14 signals silently) │ ▼ every 2 seconds via sendBeacon Signals API (FastAPI · Python · port 8002) ├── XGBoost classifier → mode + confidence ├── Redis (session state · 1hr TTL) └── ClickHouse (permanent storage · training data) │ ▼ Experience API (FastAPI · Python · port 8001) ├── reads Redis for session mode ├── returns template instructions (JSON) └── 10% control group (always shows default — for measurement) │ ▼ OCC Middleware (Node.js · Express · port 3000) ├── calls SAP Commerce Cloud OCC API → real product data ├── calls Experience API → CCO instructions └── merges both → single response to browser │ ▼ Browser adapter └── CTA changes · sections hide · trust signals appear Source: Image by the author. The plug-and-play design is the key architectural decision. The CCO Core — the classifier, APIs, and tracker — never changes regardless of which commerce platform the client uses. Only the adapter layer is platform-specific. SAP Commerce Cloud was the first integration. Shopify and Salesforce Commerce Cloud adapters are in active development. Any platform exposing a REST API can be connected in days. The Project File Structure cco/ ├── middleware/ ← OCC Middleware (Node.js) │ ├── src/ │ │ ├── index.js ← Express server entry point (port 3000) │ │ ├── routes/product.js ← Merges SAP + CCO into one response │ │ └── services/ │ │ ├── occ.js ← Calls SAP Commerce Cloud OCC API │ │ └── cco.js ← Calls CCO Experience API │ └── .env ← Credentials (SAP URL, OAuth, etc.) │ ├── cco-core/ ← CCO Brain (Python/FastAPI) │ ├── signals/main.py ← Signals API (port 8002) + XGBoost classifier │ ├── experience-api/main.py ← Experience API (port 8001) + Redis templates │ ├── classifier/ │ │ ├── generate_data.py ← Generates synthetic training data │ │ ├── train.py ← Trains XGBoost model │ │ ├── cco_model.json ← Trained XGBoost model (production) │ │ └── training_data.csv ← Synthetic training data (bootstrap) │ └── pipeline/ │ ├── retrain.py ← Retraining pipeline script │ └── scheduler.py ← Weekly schedule runner │ ├── tracker/ │ ├── cco-tracker.js ← The 8KB JS tracker (drop on any website) │ └── test-page.html ← Local test page │ └── docker-compose.yml ← Redis · Kafka · PostgreSQL · ClickHouse The AI Decision: XGBoost, Not Any LLM Choosing XGBoost over any large language model — Claude, ChatGPT, Gemini, Perplexity — was a deliberate decision based on one hard constraint: 200 milliseconds. A page experience must be restructured before the customer consciously perceives the page. No LLM — regardless of provider — can classify within a page load window. Source: Image by the author. Here is the classification code: # The XGBoost inference — under 50ms def classify_mode(signals: dict) -> tuple: features = np.array([[ signals.get('spec_hover_ms', 0), signals.get('scroll_reversals', 0), int(signals.get('compare_tool_opened', False)), signals.get('visit_count', 1), signals.get('review_dwell_ms', 0), int(signals.get('checkout_clicked', False)), signals.get('session_duration_ms', 0), signals.get('scroll_speed_px_sec', 0), ]]) pred_label = int(model.predict(features)[0]) proba = model.predict_proba(features)[0] confidence = round(float(proba[pred_label]), 2) mode = LABEL_MAP[pred_label] return mode, confidence Source: Image by the author. For Arjun’s signals, this returned: Mode: hesitating Confidence: 0.84 Processing time: 48ms Cost: $0.00056 The classifier doesn’t just give a mode — it gives a confidence score. Think of it like a percentage. Arjun scored 0.84 — meaning the AI was 84% certain he was hesitating. That’s high enough to act on. Sessions scoring below 0.6 — below 60% certainty — see the default page unchanged. If the AI isn’t sure enough, it does nothing. A wrong intervention is worse than no intervention. The 8KB Tracker That Goes on Any Website The tracker is a single JavaScript file — 8 kilobytes, no dependencies. Deployed via Google Tag Manager in 10 minutes with zero code changes to the client’s website. // Signal collection — sends every 2 seconds via sendBeacon function flushSignals() { signals.session_duration_ms = Date.now() - START_TIME; const payload = JSON.stringify(signals); if (navigator.sendBeacon) { const blob = new Blob([payload], { type: 'application/json' }); navigator.sendBeacon(CONFIG.signalsUrl, blob); } } setInterval(flushSignals, 2000); window.addEventListener('beforeunload', flushSignals); The fallback rule: if the Experience API does not respond within 200 milliseconds, the page shows as normal. CCO never breaks a commerce page. The SAP Commerce Cloud Integration For the first deployment, CCO integrates with SAP Commerce Cloud 2211 using the OCC (Omni-Commerce Connect) API. The architectural decision: Spartacus adapter vs OCC middleware. A Spartacus adapter works only if the client’s storefront is built on Spartacus. An OCC middleware layer works with Spartacus, Accelerator (JSP), custom React, or any frontend that consumes OCC. We chose OCC middleware — it works for every SAP client regardless of storefront. // Both API calls run in parallel — one response to browser router.get('/:productCode', async (req, res) => { const [product, experience] = await Promise.all([ occ.getProduct(productCode), cco.getExperience(sessionId, productCode) ]); res.json({ ...product, // full SAP product data cco: experience // CCO experience instructions }); }); Source: Image by the author. The 200ms timeout rule — hardcoded: async function getExperience(sessionId, productId) { try { const response = await axios.get(experienceUrl, { params: { session: sessionId, product: productId }, timeout: 200 // hard limit — if CCO is slow, show default }); return response.data; } catch (err) { return null; // timeout or error — default page shows silently } } CCO never blocks a commerce page. If our service is unavailable or slow, the default page shows as if CCO did not exist. Testing the Full Flow End to End Once all services are running, testing the complete flow takes three curl commands. Step 1 — Simulate Arjun’s signals: curl -s -X POST http://localhost:8002/signals \ -H "Content-Type: application/json" \ -d '{ "session_id": "test-arjun-001", "product_id": "816324", "visit_count": 3, "spec_hover_ms": 14200, "review_dwell_ms": 48000, "scroll_reversals": 6, "compare_tool_opened": true, "checkout_clicked": false, "session_duration_ms": 92000, "scroll_speed_px_sec": 180 }' Expected: "mode_detected": "hesitating", "confidence": 1.0 Step 2 — Get the experience: curl -s "http://localhost:8001/experience?session=test-arjun-001&product=816324" Expected: "mode": "hesitating" with "cta_text": "Add to cart — 30-day guarantee" Step 3 — Call the middleware: curl -s http://localhost:3000/api/product/816324 \ -H "x-session-id: test-arjun-001" Expected: full SAP product JSON with a "cco" block containing experience instructions. The Self-Improving Loop The retraining pipeline runs every Sunday at 2 am automatically. # Deploy or rollback decision current_accuracy = get_current_accuracy() if accuracy >= current_accuracy - 0.01: deploy(model, label_map, accuracy) requests.post('http://localhost:8002/reload-model') else: rollback() log(f"New model worse. Keeping current. ({accuracy:.3f} vs {current_accuracy:.3f})") Source: Image by the author. The retraining timeline: Week 1–6,000 synthetic sessions → 96% accuracy on synthetic data Week 6 — first real sessions with outcomes → 80%+ accuracy on real behaviour Month 6–90%+ accuracy, catching hesitation patterns earlier in the session The model gets smarter with every session. A competitor starting today starts with no data. The accumulated learning compounds. The Numbers Source: Image by the author. The control group is not optional. 10% of sessions always see the default page. Without this, it is impossible to scientifically attribute conversion lift to CCO rather than seasonal trends. Every result we report is measured against a clean control. What Comes Next Source: Image by the author. How to Try It Access the GitHub repository with complete setup scripts, synthetic training data, Docker configuration, and documentation for deploying CCO on a test environment. Honest Challenges The 200ms constraint is both a strength and a limitation. It forces architectural discipline — but it also means CCO cannot use richer signals that take longer to process. Privacy is a genuine consideration. CCO uses no personal data , but behavioural data still carries implicit information. Clients deploying CCO in regulated markets (GDPR, CCPA) should review their data governance posture before deployment. The synthetic training data bootstraps the model to 96% accuracy on simulated behaviour. Real customer behaviour is always messier. The first weeks on a live site should be treated as a calibration period. Low confidence classifications — below 0.6 — fall back to the default page automatically. Early in deployment, this fallback fires frequently. As real session data accumulates, confidence scores rise and the fallback rate drops. CCO reshapes e-commerce by bending experiences to fit the cognitive modes of buyers — not the other way around. Madhuri Kolanu · Senior Technical Lead at Capgemini · Making complex AI concepts accessible to every professional. 44 Seconds: How an AI Removed a Customer’s Fear and Recovered a £1,099 Sale was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- Media tip sheet: AI in ecology at ESA’s 2026 Annual Meeting
Media tip sheet: AI in ecology at ESA’s 2026 Annual Meeting EurekAlert!
- Elevate your campaign performance with June’s Demand Gen Drop.
Our June Demand Gen Drop offers more ways to elevate campaign performance and engage new viewers on YouTube.
- Building an AI social simulation with OASIS
A walkthrough of persona design and multi-agent social simulation Continue reading on Towards AI »
- America’s Time Capsule for 2276 Includes Futuristic Predictions From Claude
"San Francisco, famously predicted to be underwater, is not — quite."
Score: 13🌐 MovesJun 25, 2026https://gizmodo.com/americas-time-capsule-for-2276-includes-futuristic-predictions-from-claude-2000777756 - Prompting Rovo for Reliable Reports: 4 Patterns That Work
Prompting Rovo for Reliable Reports: 4 Patterns That Work Atlassian Community
- Artificial Intelligence Concepts: Practical Applications
Artificial Intelligence Concepts: Practical Applications Oxford Lifelong Learning
Score: 13🌐 MovesJun 25, 2026https://lifelong-learning.ox.ac.uk/courses/artificial-intelligence-applications-3/ - AI company hires former UAB engineer, establishes HQ downtown
The office move and new hires reflect the company's growing demand in Birmingham and across the country.
- Machine Learning and Artificial Intelligence in Python
Machine Learning and Artificial Intelligence in Python Oxford Lifelong Learning
Score: 11🌐 MovesJun 25, 2026https://lifelong-learning.ox.ac.uk/courses/machine-learning-and-artificial-intelligence-in-python-2/ - From PDEs to Graphs: A Primer on Physics Simulation and Geometric Deep Learning (Part 1/2)
No physics or ML background required. Everything you need before reading how I built an AI that predicts fluid flow in seconds, in Part 2. The Hook: Twenty-Six Hours Per Iteration An engineer at an automotive company wants to know how air flows around a new side mirror design. She opens her CAD tool, exports the geometry, hands it to the simulation team, and waits. One hour for meshing. Another hour for solver setup. Twenty-four hours for the CFD run to finish. Then she looks at the result, decides the drag is too high, changes the mirror shape slightly, and starts the whole cycle again. Twenty-six hours per design iteration. If she wants to explore ten design variants, that’s a week and a half — before writing a single line of manufacturing spec. This is the reality of physics simulation in engineering today, and it’s the problem a new generation of AI tools — including a project of mine called PhysIQ, which I’ll walk through in Part 2 — is trying to solve. But before any of that makes sense, we need to build up the basics: what physics simulation actually is, what a mesh is, what a neural network is, and why a special kind of neural network (a Graph Neural Network) turns out to be a remarkably good fit for this problem. No prior background assumed. Let’s start from the ground up. What Is Physics Simulation, Really? Physics simulation means predicting how a physical system changes over time, using a computer instead of a physical experiment. Will the air flow smoothly around this car, or will it create turbulent eddies? Will this bridge bend within safe limits under load? Will this cloth drape naturally over a character in an animated film? To get there, it helps to start even further back — with the simplest physical idea there is: things change, and we have a precise mathematical language for describing how . Motion, and a Mathematical Way to Talk About Change Suppose a car is moving. Its position changes over time — at one second it’s at 10 meters, at two seconds it’s at 20 meters. The rate at which position changes is called velocity . If velocity itself changes — the car speeds up or slows down — that rate of change is called acceleration . Newton’s second law, F = ma, says that force equals mass times acceleration: physics, in this view, is fundamentally a story about how quantities change . Mathematicians have a precise tool for describing change: the derivative . The derivative of position with respect to time gives velocity; the derivative of velocity gives acceleration. An equation that involves derivatives is called a differential equation , and a huge amount of physics — pendulums, springs, falling objects, planetary orbits — can be written down entirely as a differential equation relating a few changing quantities to each other. When a quantity only changes with respect to one variable (usually time), the equation is called an ordinary differential equation (ODE) — the position of a single falling ball is a classic example. But the air flowing around a car doesn’t just change over time; it changes in the x direction, the y direction, and the z direction too, all at once and interdependently. Equations with derivatives across multiple variables like this are called partial differential equations (PDEs) , and almost every interesting engineering simulation — fluid flow, heat transfer, structural deformation — comes down to solving one. The catch is cost. For fluids specifically, the governing PDE is the Navier-Stokes equations — a relationship connecting velocity, pressure, and how both change in space and time. For almost any shape or scenario you’d actually care about in engineering, equations like this have no clean, pen-and-paper solution. You can write Navier-Stokes on a blackboard in one line, but solving it exactly for “air flowing around a car mirror” is not something anyone can do with algebra. So instead, simulation tools fall back on numerical methods : break the problem into small enough pieces that an approximate solution is tractable to compute, even if it takes a lot of computation. Here’s the core intuition for why “breaking into pieces” works, before we get to the specifics of meshes. Imagine trying to approximate a smooth curve using a computer that can only draw straight lines. One long straight line would be a poor approximation. But ten short straight line segments, each following the curve closely over a small stretch, gets you something visually indistinguishable from the real curve. More segments, better approximation — at the cost of more line segments to compute. Physics simulation uses exactly this idea, just in two or three spatial dimensions instead of one: instead of solving a PDE everywhere, continuously, we divide space into many small regions and solve an approximate, simplified version of the physics within each one. That dividing-into-small-regions step is where meshes come in. What Is a Mesh, and What Is Triangulation? Imagine the 2D cross-section of a pipe with a cylindrical obstacle in it — this is, conveniently, the actual benchmark problem used later in this series. To simulate fluid flowing around that cylinder, a solver needs to know the velocity and pressure everywhere in the domain, at every instant in time. Computing an exact, continuous answer everywhere is impossible. So instead, the domain is broken into a finite number of small, simple shapes — usually triangles in 2D, or tetrahedra in 3D — connected at shared corners. This collection of small shapes is called a mesh . A mesh has three basic ingredients: Nodes (or vertices): individual points in space Edges : the connections between adjacent nodes Faces (or elements): the small triangles (2D) or tetrahedra (3D) formed by those nodes and edges Instead of solving the PDE everywhere continuously, the solver only computes quantities like velocity and pressure at the nodes , and uses the mesh structure to estimate how those quantities vary across each small element. This is the core idea behind methods like the Finite Element Method (FEM) and Finite Volume Method (FVM) : turn a continuous, infinite-dimensional problem into a finite, discrete one that a computer can actually solve, by assembling a large system of equations — one set of unknowns per node — and solving them simultaneously. Why Triangles, and What Is Triangulation? Why break a domain into triangles specifically? Triangles are the simplest 2D shape that can tile an irregular region without gaps, and — critically — a triangle is always “flat” and non-degenerate as long as its three vertices aren’t collinear. This makes the math of estimating a smoothly-varying quantity across each triangle straightforward. Triangulation is the process of generating that triangle mesh from a set of points or boundary curves. Not all triangulations are equally good. A triangulation full of long, thin, needle-like triangles produces numerically unstable, inaccurate simulations — small errors get amplified. The gold standard is Delaunay triangulation : a specific way of connecting points into triangles such that no point lies inside the circumcircle of any other triangle. In practice, this rule tends to avoid thin slivers and produce triangles that are as close to equilateral as the point distribution allows — which keeps the numerical solver well-behaved. Mesh quality also varies by where you are in the domain. Near the cylinder surface, where velocity changes rapidly (steep gradients, boundary layers, vortex shedding), you want a fine mesh — small triangles densely packed — to capture that detail accurately. Far from the cylinder, where the flow is calm and slowly varying, a coarse mesh — large triangles — is good enough and saves a lot of computation. This deliberate variation in mesh density is called mesh refinement , and getting it right is itself a specialized skill in computational engineering. This is also where the real cost of classical simulation comes from: a fine, well-refined mesh might have hundreds of thousands or millions of nodes for a 3D problem, and the solver has to assemble and solve a system of equations at every single timestep, for potentially thousands of timesteps. That’s the “twenty-four hours” from the opening story. Neural Networks, From Scratch If you already know what a neural network is, skip ahead — but for completeness: A neural network is a function — a mathematical mapping from inputs to outputs — built out of stacked layers of simple operations. Each layer takes a vector of numbers, multiplies it by a matrix of learned weights, adds a bias, and passes the result through a nonlinear function (like ReLU, which just zeroes out negative values). Stack enough of these layers and the network can, in principle, approximate extremely complicated functions — this is the universal approximation property that makes neural networks broadly useful. The “learning” part works like this: you show the network an input, compare its output to the correct answer using a loss function (a number that measures how wrong the prediction was), and then use backpropagation — repeated application of the chain rule from calculus — to figure out how to nudge every weight in the network to make that loss slightly smaller. Repeat this millions of times over a large dataset, and the weights gradually settle into values that make the network’s predictions accurate. The specific architecture of layers matters enormously, and is usually chosen to match the structure of the data. Convolutional Neural Networks (CNNs) exploit the grid structure of images. Transformers exploit the sequential structure of text. And — as we’re about to see — Graph Neural Networks exploit the irregular, connected structure of meshes. Physics-Informed Loss: Teaching a Network the Rules of Physics Here’s an idea that sits right at the intersection of physics and deep learning: what if, instead of (or in addition to) training a neural network on labeled examples, you trained it to directly satisfy a physical law? This is the idea behind Physics-Informed Neural Networks (PINNs) . A PINN is usually a fairly ordinary neural network — often a simple multi-layer perceptron — trained to output a predicted physical quantity (say, velocity and pressure) for any given point in space and time. The twist is in the loss function. Because the network’s output is a differentiable function of its inputs, you can use automatic differentiation (the same machinery behind backpropagation) to compute the derivatives of the network’s own output — exactly the derivatives that appear in the governing PDE (like Navier-Stokes). Plug those derivatives back into the PDE, and you get a number called the PDE residual : how badly the network’s current prediction violates the physical law. That residual becomes a term in the loss function. The network is, quite literally, penalized for disagreeing with physics, even at points where there’s no labeled training data at all. It’s an elegant idea — physics itself becomes a teacher. But PINNs have real, practical limitations. Training against a nonlinear PDE residual is a hard optimization problem in its own right. A PINN trained for one specific geometry and boundary condition generally needs to be retrained from scratch if you change the shape — there’s no built-in notion of mesh connectivity or geometry in a standard MLP. And for problems that evolve over long time horizons, PINNs can drift or fail to converge cleanly. This matters because it sets up a real tension worth understanding before we get to GNNs: do you want a network that is taught the physics directly via a PDE-based loss (a PINN), or a network that learns the physics implicitly by training on many examples of mesh-based simulation data, the way an image classifier learns “catness” implicitly from thousands of cat photos? Both are valid strategies, with different tradeoffs — and it’s the second strategy, applied specifically to mesh data, that leads us to geometric deep learning. Geometric Deep Learning: Why Meshes Need a Different Kind of Neural Network Recall that a mesh is irregular: some nodes have three neighbors, some have eight; edge lengths vary depending on local mesh refinement. A standard CNN expects a grid, where pixel [i, j] always has exactly four neighbors at a fixed distance. You simply cannot slide a convolution kernel over a mesh — there’s no consistent “next node” the way there’s a consistent “next pixel.” Geometric deep learning is the field that generalizes deep learning to exactly this kind of non-Euclidean, irregular data: graphs, meshes, point clouds, manifolds. And the key realization, once you see it, is almost obvious: a mesh basically is a graph already. Nodes are mesh vertices. Edges are the connections between them. All that’s missing is a way to do something convolution-like — aggregating local neighborhood information — on this irregular structure. That something is called message passing , and it’s the central operation in a Graph Neural Network (GNN). One round of message passing works like this: Message : for every edge connecting node i and node j, compute a “message” — a vector of numbers — that depends on the features of both nodes and the edge itself. Aggregate : for every node i, collect all incoming messages from its neighboring nodes — typically by summing or averaging them together. Update : combine node i’s current features with the aggregated messages to produce its new, updated features. This single round of message passing lets each node absorb information from its immediate neighbors. Stack many rounds — many “layers” of the GNN — and information propagates further across the mesh with each layer, the same way information would propagate several hops away in a single pass. This isn’t just a clever computational trick to make graphs work with deep learning — it’s a genuinely physical match. In a real fluid or solid, a disturbance at one point physically propagates to its neighbors first, and from there to their neighbors, and so on. Message passing on a mesh graph respects exactly the same locality structure as the physics it’s trying to model. That correspondence is the whole reason GNNs turn out to be such a natural fit for learning physics simulation directly from mesh data — which is exactly the approach behind PhysIQ, covered in Part 2. Three Strategies, Side by Side Putting it all together, there are roughly three distinct strategies for “physics AI” worth knowing about: Physics-Informed Neural Networks (PINNs) — bake the governing PDE directly into the training loss. No simulation data strictly required, but limited generalization across geometries and slow to train. Neural Operators (e.g. Fourier Neural Operators) — learn a mapping between entire input and output fields rather than fixed-size vectors, working naturally on regular grids but requiring awkward interpolation on unstructured, irregular meshes. Data-driven mesh surrogates (Graph Neural Networks) — train a GNN directly on a dataset of mesh-based simulation trajectories (input mesh and boundary conditions → solution over time), and use it instead of the solver at inference time. This generalizes naturally across arbitrary mesh topologies, at the cost of needing a dataset of real simulation runs to learn from. Each strategy makes a different bet about where the “physics knowledge” should live: explicitly in the loss function, implicitly in a learned operator over fields, or implicitly in a learned operator over graphs. PhysIQ is built on the third approach, following the architecture introduced by DeepMind’s MeshGraphNets — and that’s where Part 2 picks up. The Big Picture, Side by Side It’s worth stepping back and looking at the two pipelines next to each other — the classical one, and the one machine learning enables: Classical simulation: Physics equations (PDEs) ↓ Mesh (triangulation, refinement) ↓ Numerical solver (FEM / FVM, every timestep) ↓ Result — hours or days later Machine-learning simulation: Thousands of pre-computed simulations ↓ Train a Graph Neural Network on that data ↓ New geometry comes in ↓ Prediction — seconds later The classical pipeline re-solves the same physics from scratch, every single time, for every new geometry. The learning-based pipeline pays the cost once, up front, during training — and from then on, it’s not solving equations at inference time at all. It’s recognizing patterns in how solutions tend to behave, the same way an image classifier doesn’t “compute” that something is a cat, it recognizes the pattern from having seen many cats before. Continued in Part 2: a full case study of PhysIQ — the actual GNN architecture, the data engineering behind training it efficiently, how it learns to flag its own uncertain predictions, and how it can run the simulation backwards to design a shape from a target performance metric. The full codebase for PhysIQ is available at github.com/ahmealy/PhysIQ . A full demo is on YouTube . MeshGraphNets paper: Pfaff et al., “Learning Mesh-Based Simulation with Graph Networks”, ICLR 2021. arxiv.org/abs/2010.03409 From PDEs to Graphs: A Primer on Physics Simulation and Geometric Deep Learning (Part 1/2) was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- Rovo for New Atlassian Admins: 3 Agents You Can Ship Today
Rovo for New Atlassian Admins: 3 Agents You Can Ship Today Atlassian Community
- Announcing The D2C & Retail Summit 2026: Decoding Commerce In The Age Of AI & 10-Min Delivery
India’s consumer economy is entering a defining new chapter. The era of burning capital for hyper-growth is over, replaced by…
Score: 10🌐 MovesJun 25, 2026https://inc42.com/buzz/announcing-the-d2c-retail-summit-2026-decoding-commerce-in-the-age-of-ai-10-min-delivery/ - I Built My Own Analytics + AB Testing Tool with Claude Code.
I Built My Own Analytics + AB Testing Tool with Claude Code. (Part 2 of 3: A/B tests and session replay) Part 1 got events from the browser into Postgres. A pipeline that only counts pageviews is a worse Google Analytics, though. The reason to build your own is to do the things the off-the-shelf tools gate behind a sales call: run real experiments, and watch real sessions. Both turn out to lean on the same humble trick: a hash function. A/B testing without the flicker Most A/B tools ship a library that rewrites your DOM after the page loads. You’ve seen the result: the original headline flashes for 200ms, then snaps to the variant. It looks broken because it is. I went the other way. A test is two URLs, control and variant, and the tracker redirects a share of traffic before the page paints. You build the variant as a real page. No DOM surgery, no flash. The cost is that you maintain two pages instead of patching one, which for landing pages is a trade I’ll take every time. The same visitor, the same bucket, forever The hard requirement: a visitor must always land in the same variant, and I refuse to store a server-side record of who saw what. A hash gives you exactly that: a stable decision out of thin air. Hash the visitor ID together with the test ID, get a number between 0 and 1, and walk the variant weights: function hashToFloat(str) { // FNV-1a var h = 0x811c9dc5; for (var i = 0; i < str.length; i++) { h ^= str.charCodeAt(i); h = Math.imul(h, 0x01000193); } return (h >>> 0) / 0xffffffff; } var bucket = hashToFloat(visitorId + test.id); var cumulative = 0, assigned = null; for (var i = 0; i < test.variants.length; i++) { cumulative += test.variants[i].weight; if (bucket <= cumulative) { assigned = test.variants[i]; break; } } No database of assignments. No coordination. The same person hashes to the same bucket every visit, and mixing in the test ID means their bucket in one test tells you nothing about the next. Two details that look small and aren’t When you redirect to the variant, carry the query string over. Forget this and you strip the UTM and ad-click parameters off the URL, and your paid traffic suddenly looks like it came from nowhere: var variantUrl = new URL(assigned.url, location.origin); new URLSearchParams(location.search).forEach(function (v, k) { if (!variantUrl.searchParams.has(k)) variantUrl.searchParams.set(k, v); }); location.replace(redirectUrl); // replace(), so "back" skips the redirect And fail fast. The assignment request gets a 2-second timeout, and every failure path does nothing and lets the page load: xhr.timeout = 2000; xhr.ontimeout = function () {}; // show control, move on xhr.onerror = function () {}; A visitor who sees the control because your API was slow is a non-event. A visitor staring at a blank page because you blocked render on a database query is a refund. Calling the test without fooling yourself Because Part 1’s tracker stamps ab_variant onto every event, results are one grouped query: visitors and conversions per variant. The honesty lives in what you do with those counts. I wrote the stats with zero dependencies, and it's less code than the npm install would be. A two-proportion z-test answers “is this difference real or just noise?” const p1 = controlConversions / controlVisitors; const p2 = variantConversions / variantVisitors; const pPooled = (controlConversions + variantConversions) / (controlVisitors + variantVisitors); const se = Math.sqrt(pPooled * (1 - pPooled) * (1 / controlVisitors + 1 / variantVisitors)); const zScore = (p2 - p1) / se; const pValue = 2 * (1 - normalCDF(Math.abs(zScore))); But the number that keeps you honest is the confidence interval. “Variant B converts at 3.2%” invites you to celebrate. A Wilson interval of “3.2%, somewhere between 1.1% and 5.9%” tells you the truth: you don’t know yet. It’s the same midpoint, but showing the range is what stops people calling a win off forty visitors on a Tuesday. The same file computes the sample size you need before you start, so “how long do we run this” has a real answer instead of a gut feel. There’s an auto-stop flag too: a scheduled job watches running tests and routes everyone to the winner once it clears the threshold. Session replay, scoped so it doesn’t bankrupt you Watching someone use your page is worth a hundred funnel charts. It’s also the heaviest thing in the whole system, so the scope is aggressive: replay records only A/B test sessions, and only a sample of those. If you’re recording everyone, you’re paying to store screensavers. Lazy loading protects the budget The recorder is bigger than the entire tracker, so it never ships in the main snippet. It loads only after a visitor is bucketed into a test: function initReplay() { if (replayStarted || !abTestId || isPreview) return; // tests only var s = document.createElement('script'); s.src = currentScript.src.replace(/pp\.js/, 'pp-replay.js'); s.onload = function () { window.__ppReplay.initReplayRecording(/* session context */); }; document.head.appendChild(s); } Visitors who aren’t in an experiment never download a byte of it. That’s how you keep Part 1’s 5KB promise. Don’t write the recorder. Use rrweb. rrweb takes a DOM snapshot and then streams mutations, so replay is just rebuilding the page and replaying changes on a timeline. Reimplementing it is a months-long sinkhole. Configure it for privacy and noise up front: record({ emit: function (e) { buffer.push(e); }, maskAllInputs: true, // never record what people type blockSelector: '[data-pp-block]', sampling: { mousemove: 50, scroll: 150, input: 'last' }, }); maskAllInputs: true is the default, not a setting you remember to flip. Record one password field by accident and your analytics tool is now a breach waiting to happen. Mask everything; let sites unmask on purpose. Same hash trick, different job A half-recorded session is useless, so the record/skip decision is made once, deterministically, from the session ID, the exact same move as A/B bucketing: var hash = 0; for (var j = 0; j < sessionId.length; j++) hash = ((hash << 5) - hash + sessionId.charCodeAt(j)) | 0; if (Math.abs(hash) % 100 >= sampleRate) return; // default 50% Chunk it, or lose it Recordings run minutes and hit megabytes. Buffer the whole thing and send at the end, and a tab that dies takes everything with it. So events flush as numbered chunks every 5 seconds, with the first chunk going out after just 1 second. It holds the bulky initial DOM snapshot, and flushing it early means even a two-second bounce leaves something watchable. The final chunk rides sendBeacon; the rest use XHR, which has no size cap. Storage is two tables: one row of metadata per recording, many bytea chunk rows ordered by index. To play it back, fetch the chunks in order, concatenate, hand them to the rrweb player. One gotcha: a killed tab never sends its "final" chunk, so a cron job marks any recording with no new chunk in 60 seconds as done. Skip that and your "in progress" list grows forever. The iframe trap If your page embeds another origin in an iframe (say a site builder wrapping an embedded scheduler), rrweb can’t see inside it, and the cross-origin recording option in rrweb v2 crashed outright on me. The workaround: a separate script inside the iframe records it independently, the parent broadcasts session context via postMessage (re-broadcasting to late-arriving iframes with a MutationObserver), and the dashboard stitches the two recordings back together by session ID. It's fiddly. It's also the only way to see inside frames you don't own. Two experiments-grade features, both resting on a hash function and a respect for not blocking render. You can now run honest tests and watch the sessions behind them. In Part 3 (to be published next week) , the part I find genuinely fun: feeding all of this, the events, the test results, and your actual customer calls, to an LLM that hands back advice specific enough to ship. Build it yourself with Claude Code The companion docs hold the full version of everything above: the complete redirect logic, the whole stats engine, the rrweb config, and the iframe workaround in full: A/B testing : hash bucketing, redirect-without-flicker, and the dependency-free z-test / Wilson interval / sample-size math. Session replay : rrweb setup, chunked upload, the storage schema, and the cross-origin iframe fix. How to use them: read alongside the post, or hand a doc to Claude Code and have it scaffold the piece. The stats doc in particular is exact enough to generate the whole significance.ts file from. No stats library required. I Built My Own Analytics + AB Testing Tool with Claude Code. was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- Cannabis robotics company Vape Jet moves headquarters to Strip District
The company manufactures robotics equipment that automates cannabis vape cartridge filling. The move comes as recreational cannabis remains illegal in Pennsylvania.
Score: 10🌐 MovesJun 25, 2026https://www.bizjournals.com/pittsburgh/news/2026/06/25/vape-jet-relocates-to-strip-district.html?ana=brss_6150