AI News Archive: June 22, 2026 — Part 7
Sourced from 500+ daily AI sources, scored by relevance.
- Super Micro’s stock is seeing its best run in a year thanks to Nvidia partnership
Super Micro shares were leading the S&P 500’s gainers on Monday.
- Acodyne secures €2.5M to develop next-generation autonomous logistics aircraft
Copenhagen-based deep tech startup Acodyne has raised €2.5 million in pre-seed funding to scale its unmanned eVTOL cargo aircraft for heavy-lift logistics in defence, offshore, and remote operations. ...
Score: 47🌐 MovesJun 22, 2026https://tech.eu/2026/06/22/acodyne-secures-eur25m-to-develop-next-generation-autonomous-logistics-aircraft/ - Westpac brings automation and AIOps to life, chasing CPU and memory alerts
Reinforces priority focus areas.
- Cyber Acoustics Introduces ACCESS AI Workforce Verification Platform Alongside Next-Generation Headsets for Call Centers
Cyber Acoustics Introduces ACCESS AI Workforce Verification Platform Alongside Next-Generation Headsets for Call Centers Toronto Star
- The Agentic Enterprise: AI Governance for Marketing Leaders
Learn how marketing leaders can govern agentic AI with strong data foundations, privacy controls and clear accountability across the enterprise.
Score: 47🌐 MovesJun 22, 2026https://www.snowflake.com/content/snowflake-site/global/en/blog/mmds-ai-governance-framework-agentic-enterprise - How Law Firms Use AI to Win More Clients
Examines strategies law firms employ AI to attract and retain clients.
- The Open-Weights Underdog Nobody Is Talking About: GLM 5.2
While the entire technical industry is hyper-focused on copying standard GPT-style decoders, a quiet architectural divergence has built a massive lead. Here is the engineering reality. 1. The Causal Illusion We have been lulled into a deep architectural sleep. Almost every large language model you download from Hugging Face is built on the same exact template: a standard, left-to-right next-token prediction causal decoder. It is easy to train, easy to scale, and incredibly predictable. But it has a glaring, structural weakness. By treating the context window as a flat, unidirectional sequence, standard causal decoders suffer from a severe degradation when processing rich, complex, in-sequence relational structures. Our long-context pipelines, retrievers, and RAG pipelines are paying a massive computational tax because of this single, lazy architectural consensus. Is there a better way? Here is the thing nobody tells you: while the Silicon Valley consensus was busy copy-pasting the same attention heads, researchers at Zhipu AI and Tsinghua University took a completely different path. They built the General Language Model (GLM) architecture. It is an open-weights design that completely departs from standard GPT-style autoregressions. And with the release of the GLM 5.2 family, the performance gap has suddenly become impossible to ignore. 2. The Magic is in the Blank-Filling To understand why GLM 5.2 outperforms standard models at long-context comprehension and reasoning, we need to look at what actually happens under the hood. Standard models predict the absolute next word in line. They look backward, and try to guess what comes forward. GLM does not play that game. Instead, it is trained on an autoregressive blank-filling objective. Think of it like a smart editor filling in the blanks of a rough draft. It masks random contiguous spans of tokens from the input context, and then trains the network to reconstruct those exact blanks autoregressively. This is not the standard bidirectional masking of BERT, which was famous for being elegant for search but terrible for long-form generation. Instead, it is a brilliant hybrid. It routes the context block with fully bidirectional self-attention, and routes the masked block using an autoregressive causal matrix. Let me show you how this looks in a physical diagram: This vector demonstrates Zhipus unique autoregressive fill mechanism. Input context A achieves bidirectional attention routing, while masked targets B self-attend causally to maintain structural syntax 3. Direct Token Transitions & Agentic Loops Most tutorials stop at simple prompt engineering. Don’t. If you want to build systems that actually survive in production, you need to understand tool execution latency. You have probably seen this go wrong. In standard agentic frameworks, a tool call requires a massive, multi-turn sequence: 1. The model outputs a JSON string or XML wrapper. 2. The middleware framework (like LangChain) intercepts the output, parses the string, handles syntax errors, and runs the function. 3. The result is serialized into a heavy block of text. 4. The system sends a new request, repeating the entire system prompt and context. The dirty secret is that this multi-turn parser loop easily adds 500ms to 2 seconds of pure network and middleware latency. It is completely fragile. GLM 5.2 solves this at the pre-training layer. By embedding tool execution as a native token transition directly inside the model’s pre-trained vocabulary, tool and action outputs do not require a separate execution loop. They are mapped into unified logits. When the model needs to call stock metrics or interact with database drivers, it fires a native token sequence, mapping parameters into optimized execution slots instantly. We are talking about a latency drop from 1.2 seconds down to less than 50 milliseconds. This is where 90% of developers get stuck when trying to build low-latency interfaces: they are fighting a routing battle that should have been fought during pre-training. In GLM 5.2, integrated agentic loops do not rely on middleware parse loops. Real-time actions are mapped straight into token probabilities, preventing parsing errors. 4. What Everyone Gets Wrong About Open Weights The absolute biggest misconception in the open-source community is that you only need to look at the top three models on the LMSYS leaderboard. It is easy to look at standard leaderboard rankings and conclude that Qwen or Llama is the undisputed king of open-source weights. But the dirty secret is that leaderboards are heavily weighted towards simple, single-turn human preferences. They are incredibly poor indicators of real-world corporate reliability: - RAG Context Collapse: Standard causal decoders suffer from severe semantic degradation in the “middle” of the context window. They lose track of arguments if they are sandwiched between massive rows of documents. - Agentic Halting: Standard decoders lack structured-output stability. They will suddenly output invalid characters or freeze, halting the entire logic loop. - Dense Token Efficiency: Standard models require massive scale to retain factual mapping, whereas GLM’s bidirectional context routing achieves the same empirical accuracy with 40% fewer parameters. Ever wondered why Zhipu’s tech is silently powering some of the highest-throughput production services across Asia? Now you know. It isn’t because of marketing. It is because of structural pre-training math. 5. A Production Pipeline That Bypasses the Fluff Let’s look at a concrete, practical example. Imagine you are building an automated customer support terminal that must fetch real-time shipping dates, cross-reference them with user records, and instantly synthesize a polite human response. Normally, you would spin up a massive, multi-agent orchestrator. With GLM 5.2, we bypass the middleman entirely. Because the tool-calling parameters are mapped directly into native logit emissions, we can write a simple, deterministic pipeline in Python that queries the model and processes the structured output with zero external framework dependencies: # A lightweight, ultra-low-latency deterministic execution structure import os from google import genai # Assuming similar API SDK patterns or direct GLM endpoints # Direct model query without agentic wrappers def query_glm_native(user_query: str): # GLM 5.2 maps tool tokens as native token transitions # instead of heavy XML wrapping response = client.models.generate_content( model='glm-5.2-chat', contents=user_query, config=types.GenerateContentConfig( tools=[shipping_api, user_records_api], temperature=0.0, # Complete deterministic precision ) ) # Process native logit emissions directly if response.function_calls: for call in response.function_calls: # Executes in a fraction of a millisecond result = execute_native_tool(call.name, call.args) return result return response.text ``` Most tutorials add hundreds of lines of Langshain boilerplate. Don’t fall for it. By leveraging native token transitions, your microservices remain lightweight, robust, and lightning-fast. 6. The Departure Wait… before you move on. We are at a critical junction in open weights. The consensus is trying to convince us that the current standard architectures are the final evolution of large language models. They want us to believe that the only way forward is to build larger and larger clusters, consuming massive amounts of power to train the same standard left-to-right prediction engines. It is a comfortable lie. But it is a dead end. The real future of open-weights intelligence belongs to the developers who look beyond the monoculture. It belongs to the architectures that challenge the training objective itself. Next time you spin up an agent, ask yourself: are you building on a platform optimized for conversation, or are you building on an architecture optimized for execution? The choice you make today determines the latency of your application tomorrow. The Open-Weights Underdog Nobody Is Talking About: GLM 5.2 was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- Caterpillar’s stock hits a milestone as AI-fueled industrials rally sweeps up Wall Street
Caterpillar is the hottest stock in the Dow this year, and now one of just two in the index with a share price above $1,000.
- Egypt opens applications for Presidential African Youth in AI and Robotics competition 2026
The competition features 12 tracks covering sectors and disciplines, including healthcare, education, agriculture
- Debunking the Myths That AI Data Center Critics Believe
Debunking the Myths That AI Data Center Critics Believe The Information
Score: 45🌐 MovesJun 22, 2026https://www.theinformation.com/newsletters/ai-infrastructure/debunking-myths-ai-data-center-critics-believe - AI is cursing renters with the promise of impossible homes
Joyce, a native New Yorker, didn't think finding her first solo apartment in the city would be easy. But she also didn't think it'd be "hell." After looking at a lot of tiny, overpriced places she described as "shitholes," Joyce found her dream apartment: a reasonably priced studio in Manhattan. "It was big and airy, […]
Score: 45🌐 MovesJun 22, 2026https://www.theverge.com/report/953888/ai-virtual-staging-real-estate-apartment-listings - AI wants to plunder everything to keep its bubble afloat
AI wants to plunder everything to keep its bubble afloat The Telegraph
Score: 45🌐 MovesJun 22, 2026https://www.telegraph.co.uk/business/2026/06/22/ai-wants-plunder-everything-keep-its-bubble-afloat/ - Students Are Increasingly Using AI to Cheat — And Getting Away With It
Students Are Increasingly Using AI to Cheat — And Getting Away With It entrepreneur.com
Score: 45🌐 MovesJun 22, 2026https://www.entrepreneur.com/business-news/students-are-increasingly-using-ai-to-cheat-and-getting-away-with-it - AI is driving an already expensive housing market nuts in San Francisco
The AI boom has helped San Francisco turn around its Covid-era woes - but rent hikes and people buying for a million over the listing price is setting nerves on edge, Josh Marcus reports
Score: 45🌐 MovesJun 22, 2026https://www.independent.co.uk/us/money/san-francisco-housing-rent-ai-b3000629.html - 75,000 AI songs a day, but Europe’s music startups are looking somewhere smarter
Two years ago, a Sónar+D panel called “Generating Panic?” asked whether AI was about to overwhelm music. By April 2026, Deezer had a number: around 75,000 fully AI-generated tracks a day, about 44% of all the new music arriving on the platform. The panel asked, the data answered. Then you look at what people play. […] The post 75,000 AI songs a day, but Europe’s music startups are looking somewhere smarter appeared first on EU-Startups .
- Why Your AI Agent Fails After 3 Days (And the 3-Layer Architecture That Fixes It)
Build production-ready agent loops with durable orchestration. 3 layers, working code, real-world patterns. From someone who learned this the hard way. The 3-day failure story — how a simple agent loop breaks in production without durable orchestration. Who this is for: Backend engineers and technical leads building production-grade agent systems. You should be comfortable with TypeScript, familiar with async/await, and have deployed at least one agent to production (and watched it break). Who this is NOT for: If you are currently experimenting with Claude in a Jupyter notebook, this architecture is overkill. Disclosure: I am a user of Inngest and have built production systems with their engine. This article uses Inngest as a reference implementation, but the architectural pattern is entirely tool-agnostic and applies to any durable execution platform (Temporal, AWS Step Functions, Restate, etc.). Everyone’s asking, “WTF is a loop?” Here’s the question nobody’s asking: what runs the loop? The AI discourse has converged on loops as the core primitive of agentic systems. Industry leaders have meticulously broken down the building blocks inside them — automations, worktrees, skills, and hierarchical supervision loops. But the current conversation misses the underlying execution layer. Without durable orchestration , your loop dies on restart, duplicates destructive actions, and burns unnecessary tokens. I learned this the hard way. Six months ago, we built an autonomous agent designed to process incoming customer support tickets. It performed flawlessly in development. Then we deployed it to production. After three days of heavy load, the underlying server suddenly restarted due to an out-of-memory (OOM) error. When the process came back up, the agent blindly re-processed the last 47 tickets from scratch. It sent duplicate API calls and duplicate email responses to customers. Our support channel was instantly flooded with complaints. That was the moment I realized: a loop that cannot survive a process restart isn’t a loop. It’s a liability. In this article, you’ll discover: ✅ Why simple while True loops fail in production ✅ The 3-layer architecture: Loop + Skill + Orchestrator ✅ How to implement durable execution (Inngest + Temporal examples) ✅ Real metrics: 34% token savings, 20 hours/week saved ✅ When you DON’T need this architecture (honest take) ✅ How to choose the right orchestration engine Where Simple Loops Break Handling single-agent, single-session work in a short-lived environment is straightforward. An agent runs until a specific task is finalized. But as you scale to enterprise-grade operations, the infrastructure requirements change dramatically. You quickly hit tipping points where loops must: Supervise other autonomous loops asynchronously. Run on strict cron schedules, rather than relying on human triggers. Survive runtime crashes, infrastructure deploys, and spot instance reclamations. Spawn decoupled sub-agents and pause to wait for results hours later. Maintain rigorous post-hoc observability for audit trails. This isn’t a prompting problem. It is a distributed systems infrastructure problem. The costliest thing in production AI is no longer writing the code; it’s managing the state of the agent loop. Running a while True statement inside a terminal or a long-running process on a bare virtual machine guarantees state loss. When your host restarts mid-execution, you lose context. The system starts over. It re-fetches data it already processed. It re-calls expensive LLMs for decisions it already finalized. It sends duplicate Slack messages, charges credit cards twice, and spawns clone sub-agents. The remedy isn’t “better error handling.” It is a structural execution model where each step is checkpointed, each decision is persisted, and recovery means seamlessly resuming from the exact point of failure. The Three-Layer Architecture An enterprise-grade agent loop architecture relies on three distinct layers, each mapping to a concrete engineering primitive. The three layers that make agent loops reliable. Layer 1: The Loop A loop is a heartbeat clock paired with an intelligent decision-maker. It runs on a schedule or an event trigger, evaluates the current system state, and dictates the next logical action. Unlike a traditional cron job, this model has a cognitive decision engine in the middle. The agent decides the path forward, not a static hardcoded script. The cron or event streaming bus acts as the heartbeat; the LLM is the decision-maker; and the orchestration steps serve as the durable checkpointing ledger. export const infraHealthCheck = inngest.createFunction( { id: "infra-health-check" }, { cron: "*/30 * * * *" }, // Every 30 minutes async ({ step }) => { const metrics = await step.run("fetch-service-metrics", async () => { return await fetchServiceMetrics(); // error rates, latency, memory, CPU }); const assessment = await step.run("assess-health", async () => { return await callLLM({ prompt: `Given these service metrics, classify overall system health as "normal", "degraded", or "critical". Explain your reasoning. Metrics: ${JSON.stringify(metrics)}`, }); }); if (assessment.status === "degraded" || assessment.status === "critical") { await step.invoke("triage-incident", { function: incidentTriage, data: { metrics, assessment, services: assessment.affectedServices }, }); } } ); Layer 2: The Skill The loop itself is just plumbing. The real asset is the skill it calls — the durable, reusable workflow that compounds over time. A skill is not just a clever system prompt. It is a multi-step, retryable, composable, and independently deployable unit of work. Each new skill your system masters makes every loop across your organization significantly more capable. export const incidentTriage = inngest.createFunction( { id: "incident-triage", retries: 3 }, { event: "infra.incident.triage" }, async ({ event, step }) => { const details = await step.run("fetch-detailed-metrics", async () => { return await fetchDetailedMetrics({ services: event.data.services }); }); const deploys = await step.run("fetch-deploy-history", async () => { return await fetchRecentDeploys({ since: hoursAgo(2) }); }); const analysis = await step.run("correlate-incident", async () => { return await callLLM({ prompt: `Correlate these service metrics with recent deploys. Identify the likely root cause and severity. Metrics: ${JSON.stringify(details)} Recent deploys: ${JSON.stringify(deploys)}`, }); }); await step.run("post-triage-summary", async () => { await slack.postMessage({ channel: "#incidents", text: formatTriageSummary({ analysis, affectedServices: event.data.services, recommendedActions: analysis.recommendations, }), }); }); return analysis; } ); Layer 3: The Orchestrator The orchestrator is the invisible engine running the entire topology. It schedules crons, commits step state to a persistent ledger, manages backoffs, enforces strict concurrency limits, and enables hot-deploys of new functions without terminating active, in-flight runs. Agents are often simplified as LLM + tools. The agent loop architecture reframes this completely: agents are loops + skills + orchestration. The LLMs and deterministic tools sit safely inside the loops, decoupled from the underlying state machine. Implementation: Agnostic Code Design To understand how this functions in production, let’s examine an Incident Triage workflow. If a monitoring loop detects an infrastructure anomaly, it triggers this skill to isolate the root cause. Here is how this pattern translates across different execution models, demonstrating that the architectural concept is entirely independent of any single SDK: 1. Conceptual Workflow (Tool-Agnostic) Step A: Fetch precise infrastructure metrics from a monitoring API. [Save State] Step B: Fetch recent deployment logs from the CI/CD pipeline. [Save State] Step C: Feed metrics + logs into the LLM to identify correlations. [Save State] Step D: Post a structured markdown alert to engineering channels. [Finalize] 2. Implementation via Inngest SDK // Event-driven, step-based execution engine export const incidentTriage = inngest.createFunction( { id: "incident-triage", retries: 3 }, { event: "infra.incident.triage" }, async ({ event, step }) => { const details = await step.run("fetch-detailed-metrics", async () => { return await fetchDetailedMetrics({ services: event.data.services }); }); const deploys = await step.run("fetch-deploy-history", async () => { return await fetchRecentDeploys({ since: hoursAgo(2) }); }); const analysis = await step.run("correlate-incident", async () => { return await callLLM({ prompt: `Correlate these metrics with recent deploys: ${JSON.stringify(details)}. Deploys: ${JSON.stringify(deploys)}`, }); }); await step.run("post-triage-summary", async () => { await slack.postMessage({ channel: "#incidents", text: analysis.summary }); }); return analysis; } ); 3. Equivalent via Temporal Workflow // Code-as-configuration via deterministic proxy activities import { proxyActivities } from '@temporalio/workflow'; import type * as activities from './activities'; const { fetchDetailedMetrics, fetchRecentDeploys, callLLM, postSlackMessage } = proxyActivities ({ startToCloseTimeout: '1 minute' }); export async function incidentTriageWorkflow(event: IncidentEvent): Promise { // Each activity automatically checkpoints progress to the Temporal cluster const details = await fetchDetailedMetrics(event.services); const deploys = await fetchRecentDeploys(); const analysis = await callLLM(details, deploys); await postSlackMessage(analysis.summary); } Fault Tolerance & Failure Recovery Happy paths are easy to engineer. Production software is defined by how it handles structural failures. Imagine your incident triage skill fires at 3:00 AM, and your infrastructure metrics API throws a 503 Service Unavailable error. In a standard script, the process crashes, losing all context. With durable orchestration, the runtime isolates the failure to that specific step. The orchestrator applies an exponential backoff policy, retrying only the failed fetch-detailed-metrics step. If the API recovers ten minutes later, the workflow resumes seamlessly. It moves straight to the deployment log step without ever re-executing completed operations. Checkpointing lets you resume from failure, not restart. But what if a failure is unrecoverable — such as an expired LLM API key? You must handle catastrophic dead ends gracefully. export const incidentTriageWithFailureHandling = inngest.createFunction( { id: "incident-triage-with-handler", retries: 3, onFailure: async ({ error, event, step }) => { // Executed automatically after all step-level retries are completely exhausted await step.run("notify-ops-team", async () => { await slack.postMessage({ channel: "#agent-ops", text: `🚨 Critical Alert: Agent skill failure due to: ${error.message}. Input state preserved.` }); }); }, }, { event: "infra.incident.triage" }, async ({ event, step }) => { // Core workflow execution logic... } ); Six months of production metrics. When retries are entirely exhausted, the onFailure hook executes. It preserves the exact historical event payload, alerts human operators via an out-of-band channel, and keeps the state intact. Step-level checkpointing is more than a system reliability feature — it prevents financial waste. If a multi-step agent fails on step 9 out of 10, restarting from zero forces you to regenerate thousands of tokens across the previous 8 successful steps. Checkpointing eliminates this compounding token drain. The Self-Evolving System When your agent has access to an orchestration engine, the platform shifts from static automation to an evolving ecosystem. The agent process can hot-reload and register new functions dynamically without interrupting or terminating running tasks. Consider an automated Review Loop that runs every Friday morning. It reads its own execution history directly from the orchestrator’s database to run performance self-audits: export const reviewSkillPerformance = inngest.createFunction( { id: "review-skill-performance" }, { cron: "0 10 * * 5" }, // Executed every Friday at 10:00 AM async ({ step }) => { const runs = await step.run("fetch-run-history", async () => { return await getOrchestratorHistory({ functionId: "incident-triage", since: daysAgo(7) }); }); const analysis = await step.run("analyze-performance", async () => { const successRate = runs.filter(r => r.status === "completed").length / runs.length; const falsePositives = await queryUserFeedbackLogs(); return await callLLM({ prompt: `Analyze execution history. Success Rate: ${successRate}. False Positives: ${falsePositives}. Should we modify the underlying alerting thresholds?`, }); }); if (analysis.shouldModify) { await step.invoke("optimize-core-skill", { function: coreAgentDeveloper, data: { patches: analysis.proposedChanges }, }); } } ); This review mechanism isn’t magic; it is a structured cron job with an LLM sitting in the decision-maker’s seat. It analyzes historical run traces, evaluates accuracy against human feedback, and systematically refines its own code parameters. What about concurrency conflicts? If an infrastructure outage triggers dozens of duplicate alerts simultaneously, the orchestrator handles them via distributed queues. By setting a concurrency ceiling (limit: 1), subsequent triage attempts wait in an ordered queue until the active run completes. This guarantees no duplicate alerts, no race conditions, and no token storms. Real Numbers: Six Months in Production Six months of production metrics. We transitioned our internal operations to this durable three-layer architecture. Here are the audited results from our production cluster over a 6-month period: Autonomous Agents Deployed: 12 active systems (spanning customer support, live incident triage, and data pipeline monitors). Skills Synthesized: 47 unique workflows (the core agent autonomously authored and registered 31 of them via our sidecar process). Infrastructure Recovery Rate: 100%. The underlying infrastructure suffered 3 sudden hard restarts; every single in-flight agent loop recovered automatically without state or data loss. Token Spend Reduction: 34% saved by utilizing step-level checkpointing, preventing agents from re-running resource-heavy LLM evaluations after transient network timeouts. Operational Velocity: Saved roughly 20 hours per week of developer time by shifting from manual incident triaging to automated alerting. Alert Accuracy: False positive rates plummeted from 23% down to 8% within weeks, driven entirely by autonomous adjustments from the weekly optimization review loop. When You Don’t Need This Architecture Durable orchestration introduces structural overhead. It is a robust architectural choice, but it is not a silver bullet for every use case. You should pass on this design if your project falls into any of the following categories: Short-Lived, Single-Session Actions If your agent performs basic utilities that execute completely in under five minutes and require zero persistent memory between restarts, a standard, volatile while loop is completely sufficient. Early-Stage Prototyping If you are still mapping out what your agent should fundamentally do, building stateful checkpointing pipelines adds unnecessary architectural drag. Optimize for speed early on; introduce durability once your business requirements settle. Severe Budget Constraints Durable execution state machines carry infrastructure costs — whether you pay per run on managed clouds like Inngest, or inherit hosting and engineering complexity managing a self-hosted Temporal cluster. If your system runs fewer than ten low-stakes tasks a day, the return on investment isn’t there. Completely Stateless Agents If your agent acts as a simple pass-through gateway — accepting a prompt, generating an answer, and exiting without persisting historical dependencies — you have no state to checkpoint. Rule of Thumb: If your agent has crashed in production due to an unexpected restart, dropped an in-flight state payload, or triggered duplicate destructive actions — you need durable orchestration. Until you experience those operational pain points, keep your stack as simple as possible. Choosing an Orchestration Engine If you conclude that your system requires a durable foundation, you do not need to build it from scratch. The agent loop pattern is tool-agnostic. Choose an engine that aligns directly with your existing infrastructure, team velocity, and engineering budget: Inngest: An event-driven, serverless-friendly platform. It allows you to write standard code blocks using inline step.run() wrappers. It tracks state and triggers retries via network-based step delivery, making it ideal for teams targeting low operational overhead and rapid iteration. Temporal: The enterprise industry standard for durable execution. It relies on a deterministic replay model where your code is structured into strictly separated Workflows and Activities. It offers unmatched reliability for massive scale, though it requires managing a dedicated cluster backend and adheres to rigid coding constraints. AWS Step Functions: A visual, serverless workflow orchestrator deeply integrated into the Amazon Web Services ecosystem. State configurations are typically declared via Amazon States Language (JSON/YAML). It is an excellent choice if your entire application infrastructure is heavily anchored within AWS primitives. Restate: A lightweight, event-driven engine optimized for microservices and serverless environments. It uses a clean, RPC-like programming model to make service invocations automatically durable with a minimal footprint. DIY (Redis + Cron): It is entirely possible to construct a bespoke state machine utilizing Redis for step persistence and standard cron systems for heartbeat execution. However, be prepared to spend significant engineering capital rebuilding 80% of the queueing, checkpointing, and retry primitives that dedicated platforms provide natively. Summary: Build for Scale The industry conversation is slowly moving past what agents can do conceptually, shifting toward how to keep them running reliably in production. The value of an AI engineering organization isn’t wrapped up in the volatility of base foundation models. The value lies in your specialized skill library — the institutional knowledge of your team encoded as durable, executable infrastructure. If your loops reset to zero every time a server restarts, your technical compounding stalls out. The future of AI agents will not be won by the longest prompt. It will be won by the most reliable execution layer. Build your systems accordingly. What’s Next If you’ve implemented durable orchestration and want to push your architecture further, here are the advanced topics to explore next: Multi-agent coordination: How to securely orchestrate multiple agents collaborating on the same task asynchronously. Cost optimization: Advanced architectural strategies for reducing token spend at enterprise scale. Security patterns: How to restrict tool access, isolate state, and secure agent loops in zero-trust production environments. I will cover these in future articles. Follow me to stay updated on building robust AI infrastructure. 🔖 Bookmark this guide. You’ll need to refer to the templates and prompts as you build. 💬 Drop a comment below: What kind of skill are you going to build for your autonomous agent first? Why Your AI Agent Fails After 3 Days (And the 3-Layer Architecture That Fixes It) was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.
- CaoCao Mobility Joins Doubao Ride-Hailing Gray Test as AI Assistant Expands Into Real-World Services
ByteDance's Doubao AI assistant begins gray-testing ride-hailing services through CaoCao Mobility, marking another step in the platform's evolution from content AI to a gateway for physical-world services.
- Call screening to in-call agent: Can voice be AI's next growth frontier?
From Jio Call Agent to AI-powered call screening, artificial intelligence is becoming an active participant in phone conversations, raising questions around trust, transparency and human interaction
- Scaling Enterprise IT with Agentic AI - Engineering an Autonomous Service Desk
Scaling Enterprise IT with Agentic AI - Engineering an Autonomous Service Desk YourStory.com
Score: 45🌐 MovesJun 22, 2026https://yourstory.com/2026/06/scaling-enterprise-it-agentic-ai-engineering-an-autonomous-service-desk- - 15 Thai AI companies betting on products, not hype
Southeast Asia’s AI scene is sprinting ahead, and Thailand is quietly becoming its laboratory. From generative spatial design and energy‑saving AIoT to sovereign Thai language models and an “AI nose” that tastes food, a new wave of startups is turning local problems into global products. This list rounds up 15 homegrown companies that typify the […] The post 15 Thai AI companies betting on products, not hype appeared first on e27 .
Score: 45🌐 MovesJun 22, 2026https://e27.co/15-thai-ai-companies-betting-on-products-not-hype-20260622/ - Rebuilding the Workforce for an Intelligent Age
Rebuilding the Workforce for an Intelligent Age Fortune
- iOS 27: New Advanced AI Dictation Feature Is Turned Off In iPhone Beta
The first developer beta of iOS 27 is out for the iPhone. But, so far, one key part of the new Apple Intelligence is turned off by default.
- The AI world is getting ‘loopy’
The loop takes agentic AI a step further by authorizing a swarm of agents to work continuously in the background, endlessly.
- From invisible to recommended: How brands become visible to AI shopping agents
Drive visibility, sales and loyalty across human and AI shopping journeys.
- AI Can Crush Complex Projects—but It Fails at This Basic Task
A new study shows why today’s smartest models struggle to stay on task.
Score: 44🌐 MovesJun 22, 2026https://www.inc.com/samantha-stevens/ai-can-crush-complex-projects-but-it-fails-at-this-basic-task/91363183 - AI and robotics will deepen human-machine understanding
Artificial intelligence and robotics are opening new possibilities for understanding human emotions and strengthening interactions between people and machines, technology experts said on Monday ahead of the Annual New Champions Meeting, or Summer Davos, in Dalian, where innovations ranging from emotion-sensing AI systems to interactive robots are being showcased.
- How Snowflake Built an AI-Native Marketing Team
How Snowflake's Marketing AI Council turned a 600-person global team from 11% AI confidence to 93% daily usage in just over a year.
Score: 44🌐 MovesJun 22, 2026https://www.snowflake.com/content/snowflake-site/global/en/blog/snowflake-marketing-ai-council-ai-native-team - Loop Engineering for AI Agents: Building Verifiable, Self-Correcting Coding Workflows
A technical guide to how AI agents move beyond one-shot prompting through loop engineering, verification, and self-correcting coding… Continue reading on Towards AI »
- After Complaint, GEICO to Modify Cancellation Process That Uses AI
Pennsylvania Attorney General Dave Sunday reached an agreement with GEICO that should modify an artificial intelligence (AI) initiated auto insurance policy cancellation process the state alleged was unfair and confusing. The agreement stems from a complaint by a new GEICO …
Score: 43🌐 MovesJun 22, 2026https://www.insurancejournal.com/magazines/mag-features/2026/06/22/874424.htm - Training a Legal Agent With Applied Compute
Explores how to train a legal AI agent efficiently using applied compute resources.
- AI is turning CMOs into some of the most powerful executives in business
AI is turning CMOs into some of the most powerful executives in business Fortune
Score: 42🌐 MovesJun 22, 2026https://fortune.com/article/cmo-chief-marketing-officer-ai-creative-powerful-ceo-data/ - LLMs Misunderstand Luxury Brands. Here’s How to Optimize Your Marketing Strategy for AI.
A playbook for translating the visual grammar, spatial logic, and cultural associations that make luxury brands coveted by consumers.
Score: 42🌐 MovesJun 22, 2026https://hbr.org/2026/06/llms-misunderstand-luxury-brands-heres-how-to-optimize-your-marketing-strategy-for-ai - IT teams are bullish on AI tools, but they’re worried security practices can’t keep pace
IT teams are bullish on AI tools, but they’re worried security practices can’t keep pace IT Pro
- How Claude Mythos found a 15-year-old bug in Mozilla Firefox | Brian Grinstead
Watch now | 🎙️423 security fixes in one month: Brian Grinstead (Mozilla) shows the goal-loop harness behind it, and why the model was only half the story
- Why your AI pilot died in a data ownership meeting, not the demo
I have sat in enough post-pilot reviews to know how this story ends before anyone says a word. The pilot worked. The demo went well. The executive team was genuinely impressed, and someone in that room used the word “scale.” There was real energy. Leadership was aligned, the business case was solid and the timeline looked achievable. Then three months passed. Then six. The deployment is still pending, the original team has scattered and the business has quietly concluded that IT is great at demos and slow at everything that follows. I am not describing a technology failure. I am describing what happens when an AI initiative arrives at an organizational problem that predates it by years and finds no one with the authority to resolve it. What killed the deployment was the meeting nobody planned for. It happened sometime after the pilot ended and before anyone had agreed on who owned the data the model needed to operate in production. I have watched this sequence play out often enough to stop treating it as a project management gap. It is a structural one, and it was waiting long before the first model was ever trained. The data question nobody ever had to answer Most enterprises have been managing data ownership ambiguity for decades. It was survivable because the technologies they relied on could work around it. A BI team could pull a clean extract for the quarterly report. A data warehouse could house a copy of the customer record without anyone deciding who was responsible for keeping it current. Shadow IT could build departmental workarounds that served specific needs without ever touching the underlying question of where authoritative ownership sat. Data was treated as a byproduct of operations, managed by whoever built the system that produced it, with no named owner accountable for its accuracy or use. The cost of that arrangement was low enough, for long enough, that it never forced a decision. In many organizations I have worked with, asking who owns a specific dataset produces three different answers depending on who you ask. That was tolerable when the stakes were a dashboard that was sometimes wrong. It stops being tolerable when a production AI model is making workflow decisions or customer-facing recommendations based on whatever that dataset happens to contain on a given day. Putting a model into production that operates on live customer data, contract language or financial records requires someone to make binding calls about access rights, update protocols, data lineage and accountability when the underlying data is wrong. Those are not technical decisions. They are organizational ones. They require a business owner who will stand behind the data, with the authority to make and enforce decisions about how it is used, updated and governed. The data debt that accumulated across years of deferred ownership decisions does not disappear when a pilot succeeds. It surfaces when you try to scale. Organizations that had resolved this before their first AI deployment did not have better technology. They had usually been forced into the conversation by something else entirely: a regulatory exam, a failed ERP migration, a data breach that made the question of accountability suddenly expensive. The organizations that had not resolved it discovered what the ambiguity costs when AI made it impossible to defer any longer. What the meeting looks like and what it costs Here is how the meeting tends to go. The CIO or a project lead convenes the stakeholders whose data the production deployment will require. Sales says they own the customer relationship data, but Legal says the underlying record is a shared asset subject to retention policy. The data engineering team says they manage the pipeline but do not make ownership decisions about what flows through it. The CDO, if one exists, says any governance change requires a committee review and a documented policy update. Nobody is technically wrong. That is exactly what makes it so difficult to move. What follows is usually a working group, a governance charter and an executive sponsor who was not in the room when the pilot was approved. These are not bad things, but they take time and they consume organizational energy that nobody budgeted for when the pilot looked like a clean success. The AI project is now waiting on an organizational redesign question that predates it by a decade. I have seen this stall run six months. I have seen it run considerably longer. During that time, the CIO absorbs questions from the business about why the technology that worked so well in the demo is not yet live. The honest answer is that the organization is working through a governance question that the business itself has never resolved, but that answer does not land well in a status update. What the business experiences is an IT initiative that worked in a controlled environment and then stopped. That perception accumulates. The CIO who delivered an impressive pilot is now the CIO who cannot seem to execute. By the time the data question is settled, the original business champion has often moved on to other priorities. The vendor relationship has cooled. The momentum that existed in the room after the demo is gone, and rebuilding it requires re-educating stakeholders who have already withdrawn. Each deployment that stalls this way makes the next proposal harder to fund and harder to staff with the business partners who matter. The cost is not only the delayed deployment. It is the credibility spent in the gap and the reduced appetite for the initiative that comes after it. What the CIOs who got through it actually did The CIOs I have seen navigate this well made one consistent choice: they resolved data ownership before seeking approval to expand scope, treating it as a prerequisite the deployment required rather than something the deployment would eventually sort out. They forced the data conversation into the open at the level where binding decisions could actually be made. They brought it forward as a business decision, routed to whoever held authority over the relevant business processes and did not move forward until they had genuine alignment, the kind that would hold when the first access request actually landed. Some of them used the pilot phase deliberately to surface the ambiguity. They ran the pilot on a constrained, clearly-owned dataset and watched where the ownership questions appeared as they tried to expand access. They documented those specifically. By the time they were presenting pilot results to the executive team, they had a clear account of the organizational work the deployment would require alongside the technical work. They did not present this as a problem. They presented it as part of the plan, which is what it is. That approach requires more work before the first executive briefing. It is significantly faster in aggregate, and it changes what the CIO is accountable for. Framing the data conversation as a business decision, at the beginning, means the CIO is no longer absorbing blame for a governance failure that belongs to the organization. The deployment either moves forward with ownership settled or it does not move forward at all, and everyone in the room understands why. The organizations that skip this conversation tend to find out what it costs about four months after the demo. Some of them find out several times before they change the sequence. This article is published as part of the Foundry Expert Contributor Network. Want to join?
Score: 42🌐 MovesJun 22, 2026https://www.cio.com/article/4187296/why-your-ai-pilot-died-in-a-data-ownership-meeting-not-the-demo.html - As AI in the classroom becomes a mainstay, teaching critical thinking becomes essential
AI LLMs are mostly Western-centric but worldwide, AI in the classroom is becoming embedded and an authority like the teacher, requiring more critical thinking skills.
Score: 42🌐 MovesJun 22, 2026https://www.weforum.org/stories/2026/06/ai-in-the-classroom-critical-thinking/ - These 2 stocks could be big winners from the next generation of AI chips
The Investing Club holds its "Morning Meeting" every weekday at 10:20 a.m. ET.
Score: 42🌐 MovesJun 22, 2026https://www.cnbc.com/2026/06/22/these-2-stocks-could-be-big-winners-from-the-next-generation-of-ai-chips.html - Dubai hotel launches AI influencer in hospitality first for the emirate
Dubai hotel launches AI influencer in hospitality first for the emirate Arabian Business
Score: 42🌐 MovesJun 22, 2026https://www.arabianbusiness.com/business/dubai-hotel-launches-ai-influencer-in-hospitality-first-for-the-emirate - TrendAI officially launches in the UAE, marking a new era of AI-driven enterprise cybersecurity
Trend Micro introduces its enterprise cybersecurity business identity to the region as the UAE accelerates its national AI ambitions
- The brand ChatGPT recommends is almost never the one advertising, Floodlight data shows
The brand ChatGPT recommends is almost never the one advertising, Floodlight data shows Raleigh News & Observer
- Robot security guard reports for duty at KL’s bus terminal
Robot security guard reports for duty at KL’s bus terminal The Straits Times
Score: 41🌐 MovesJun 22, 2026https://www.straitstimes.com/asia/se-asia/robot-security-guard-reports-for-duty-at-kls-bus-terminal - How to build an AI agent: A complete guide for small businesses
How to build an AI agent: A complete guide for small businesses
- David Droga on AI and the end of ‘mediocre’ human-made ads
As he sees it, the advertising industry is in the throes of a profound technological shift.
Score: 40🌐 MovesJun 22, 2026https://www.semafor.com/article/06/21/2026/david-droga-on-ai-and-the-end-of-mediocre-human-made-ads - Why agentic enterprises need to become learning systems
Presented by Splunk Every day, organizations learn things their AI systems never get to use. A security analyst corrects an AI-generated investigation. A network engineer identifies the root cause of a recurring outage. An observability team discovers that a pattern of latency, logs and infrastructure changes predicts service degradation. A customer operations team learns which signals indicate an escalation is likely. Each moment contains valuable organizational knowledge. But in most enterprises, that knowledge disappears into tickets, dashboards, chat threads, post-incident reviews and the minds of individual experts. It may help solve the immediate problem, but it rarely becomes part of a reusable system that improves future AI-driven decisions. That is the next challenge for the agentic enterprise. The future will not be defined simply by who has the most capable model or the most autonomous agents. Many organizations will have access to similar frontier models. Many will deploy agents across security, IT, engineering, customer service, and business operations. The real differentiator will be whether those agents can learn from the organization around them. Not by constantly retraining the underlying model, but by capturing operational experience, converting it into institutional knowledge and making that knowledge available to future agents, workflows, and decisions. The agentic enterprise is not just an enterprise that uses AI. It is an enterprise that learns through AI. Agentic enterprises allow AI systems to learn from them The AI conversation has been dominated by model capability: larger context windows, better reasoning, faster inference, stronger tool use, and more sophisticated agentic behavior. Those advances matter. But in the enterprise, a model is only one part of the system. A model does not automatically know how a specific organization operates. It does not inherently know which remediation step solved last month’s outage, which analyst correction improved a threat investigation, which network signal preceded a service disruption, or which internal policy should override an otherwise plausible recommendation. That knowledge belongs to the enterprise. For agentic systems to improve, organizations need a way to capture that knowledge and make it reusable. In many cases, that does not require changing the model itself. It requires changing the ecosystem around the model: the knowledge base, retrieval layer, prompts, policies, guardrails, routing logic and workflows that shape how agents behave. The model may remain the same. The learning system around it becomes smarter. Feedback loops turn every outcome into a teachable moment for agents Every agentic workflow creates signals. An agent receives a request. It retrieves context, reasonsthrough possible actions, calls tools, and generates answers. A human accepts, rejects, or modifies that answer. Downstream systems reveal whether the action worked. That entire chain is valuable. AI observability gives organizations visibility into what happened: the prompt, response, reasoning path, tool calls, data sources, intermediate steps, failure modes and outcomes. Without that visibility, organizations cannot understand why an agent behaved the way it did, let alone improve it. But observability alone is not enough. The larger opportunity is to turn observed behavior into institutional knowledge. A trace should not only help a developer and operators debug an agent. It should help the enterprise understand what the agent learned, what the human corrected, what outcome followed, and what should change before the next similar event. That is the shift from monitoring AI to teaching AI. In the agentic enterprise, feedback loops connect action to outcome, outcome to knowledge and knowledge back to future action. A learning system in practice across security, observability and the network Consider a service experiencing intermittent degradation. An observability agent detects unusual latency and error rates. A network agent identifies packet loss across a specific path. A security agent notices that the same time window includes suspicious authentication behavior and unusual traffic from a previously unseen source. Individually, each agent has only a partial view. Together, they create a richer operational picture. The first time this incident occurs, human experts may need to intervene. A network engineer confirms that packet loss was caused by a misconfigured routing change. A security analyst determines that the suspicious traffic was not an attack, but a side effect of a misrouted internal service. An SRE connects the network event to the application degradation. That resolution contains knowledge the organization should not have to relearn. A mature agentic learning system would capture the traces, human corrections, topology context, security findings, observability signals and final remediation steps. It would preserve the relationship between those signals: latency pattern, network path, identity behavior, routing change and remediation. The next time a similar pattern appears, agents would not start from zero. They could retrieve the prior case, compare current conditions, recommend the proven diagnostic path and escalate with better context. The underlying frontier model did not need to be retrained. The enterprise learned. The architecture of the learning agentic enterprise A learning-oriented agentic enterprise needs more than a model or chatbot. It needs an architecture that can capture experience, turn it into usable knowledge, connect that knowledge to operational context, and govern how it changes future agent behavior. Memory preserves what happened: what the agent saw, what it did, where humans intervened, and what outcomes followed. Knowledge bases turn that experience into reusable guidance, including playbooks, examples, policies, procedures, and evidence. A data fabric connects the operational environment. The signals agents need live across logs, metrics, traces, tickets, identity systems, security tools, network telemetry, collaboration platforms, and business applications. A data fabric makes those signals discoverable, correlated, governed, and usable in context. AI observability explains how agents behave by capturing prompts, tool calls, intermediate steps, responses, feedback, and outcomes. That visibility helps organizations understand where agents succeed, where they fail, and what should improve. The control plane governs how learning becomes change: what knowledge is promoted, which prompts or policies are updated, which agents can use new information, what approvals are required, and how changes are audited. Together, these capabilities allow AI systems to improve over time in a controlled, trustworthy way that allows the enterprise to learn from its own operations. The organizations that learn fastest will win The next era of AI will not be won by models alone. It will be won by organizations that can capture what they learn from every workflow, expert correction, incident, investigation, and outcome. The most advanced agentic enterprises will not simply deploy more agents. They will build systems that allow every agent to benefit from the collective knowledge of the organization. That means connecting operational data through a data fabric. It means observing agent behavior deeply enough to understand it. It means preserving experience in memory and institutionalizing it in knowledge bases. It means using a control plane to govern how learning changes agent behavior. The future of AI is not a single autonomous agent acting alone. It is an ecosystem of agents, humans, data and controls that learns over time. The organizations that build that ecosystem will create AI systems that get better with every interaction. Not because the model is constantly changing, but because the enterprise itself is becoming more intelligent. Learn more about how Cisco Data Fabric powered by the Splunk Platform is accelerating agentic operations. Hao Yang is Vice President AI at Splunk, a Cisco Company. Sponsored articles are content produced by a company that is either paying for the post or has a business relationship with VentureBeat, and they’re always clearly marked. For more information, contact sales@venturebeat.com .
Score: 40🌐 MovesJun 22, 2026https://venturebeat.com/orchestration/why-agentic-enterprises-need-to-become-learning-systems - How AI-Powered Maps Help Restaurants Grow Revenue Without Guessing
AI-powered GIS maps help restaurants reach customers, choose sites, and grow revenue with a combination of location intelligence and predictive data.
Score: 40🌐 MovesJun 22, 2026https://www.forbes.com/sites/esri/2026/06/22/how-ai-powered-maps-help-restaurants-grow-revenue-without-guessing/ - Americans are fleeing the U.S. at record rates—an ex-Google engineer who left India to build a $7.2 billion AI firm says they’re making a mistake
Americans are fleeing the U.S. at record rates—an ex-Google engineer who left India to build a $7.2 billion AI firm says they’re making a mistake Fortune
- Three key AI stocks to watch this week with traders expecting giant moves
Micron and Cerebras report this week. Also there's heavy options activity in Super Micro.
Score: 40🌐 MovesJun 22, 2026https://www.cnbc.com/2026/06/22/three-key-ai-stocks-to-watch-this-week-with-traders-expecting-giant-moves.html - AI can help architects see the future before they build it
AI can help architects see the future before they build it Business Insider
Score: 40🌐 MovesJun 22, 2026https://www.businessinsider.com/gensler-architecture-ai-design-tools-concepts-2026-6 - Why scalable AI products are becoming critical for enterprise AI adoption and business growth
Scalability is commonly viewed as a concern for large enterprises, when in reality, it becomes critical much earlier. As businesses expand their use of AI products across teams and frameworks, scalability often determines whether an investment continues delivering value or creates new operational challenges. This focus on long-term impact is one of the reasons scalability remains a key evaluation criterion at the ET Most Innovative AI Product Awards 2026.
- How Shipway Is Using AI To Drive Post-Purchase Efficiency For India’s D2C Brands
India’s D2C economy is projected to surpass $310 Bn by 2030, and the brands driving this growth have largely mastered…
Score: 40🌐 MovesJun 22, 2026https://inc42.com/startups/how-shipway-is-using-ai-to-drive-post-purchase-efficiency-for-indias-d2c-brands/