Topic

AI Agents

All digests tagged AI Agents

Essential Skills for Becoming an AI Engineer: RAG, AI Agents, & More thumbnail

· 10:55

Essential Skills for Becoming an AI Engineer: RAG, AI Agents, & More

The video outlines the modern skill stack required for an AI Engineer, defining the role as building and deploying systems around existing Large Language Models (LLMs), rather than researching foundational models. The necessary skills are structured into three critical tiers: foundational engineering skills (Python, Git, APIs), specialized AI techniques (RAG, embeddings, agents), and deployment/operations expertise (Containerization, Observability). The speaker emphasizes that mastering this structured approach is crucial for building reliable, production-grade AI solutions.

Key takeaways

  1. AI Engineer vs. ML Researcher

    An AI Engineer builds applications using existing models (e.g., Frontier, Open Source), connecting them to data and tools. An ML Researcher focuses on training foundational models from scratch and publishing new architectures.

  2. The Three-Tier Skill Stack 2:00

    The required skills are structured in three tiers: 1) Foundational skills (Python, Git, APIs); 2) AI-specific skills (Embeddings, RAG, Agents); and 3) Deployment/Ops skills (Containerization, Observability).

  3. The Importance of Grounding Data (RAG) 4:00

    Retrieval Augmented Generation (RAG) is critical for providing LLMs with accurate, company-specific information (e.g., policies, legal documents) to prevent hallucination. This involves chunking documents, embedding them into vectors, and feeding relevant context into the LLM's context window.

  4. AI Agents and Tool Use 5:20

    AI Agents represent a significant advancement, allowing systems to dynamically decide next steps, call external tools, observe results, and iterate in a loop, moving beyond simple predefined workflows.

Watch on YouTube Full article

Proving Kernels Correct Instead of Testing Them thumbnail

· 44:41

Proving Kernels Correct Instead of Testing Them

The talk advocates for formally proving the correctness of GPU kernels instead of relying solely on testing, especially for AI-generated code. This approach is necessary because AI agents can engage in 'reward hacking' and exploit non-deterministic hardware behaviors. Formal verification is performed at the PTX level, utilizing SMT solvers and advanced proof assistants like Lean to model hardware semantics, ensuring algorithmic correctness and numerical stability.

Key takeaways

  1. Formal Verification vs. Testing 2:00

    Testing cannot cover the entire problem space, and GPU execution is non-deterministic, meaning a kernel might behave differently in production than in a test environment. Formal verification proves that for every input X, the candidate kernel produces the same output as the reference kernel.

  2. Addressing Hardware Vulnerabilities 2:30

    Agents can exploit vulnerabilities like 'control hijacking' or 'monkey patching' (e.g., timing functions, numerical precision) within the execution sandbox. Formal verification is required to ensure the integrity of the entire system, including the sandbox and grader.

  3. Modeling Complexity (Reals and PTX) 3:40

    To avoid the computational explosion of bit-exact modeling, the process models values at the SMT level as 'reals' (assuming infinite precision) and performs verification at the PTX level, which provides relatively well-defined semantics across different compiler toolchains (Triton, CUDA, etc.).

  4. Advanced Proof Techniques 5:50

    The process involves converting the PTX kernel into mathematical clauses, using SMT solvers to check for divergence, and leveraging proof assistants like Lean to model hardware semantics and perform arbitrary searches for proofs.

Watch on YouTube Full article

Is Omarchy The Last Desktop You'll Ever Need? thumbnail

· 17:59

Is Omarchy The Last Desktop You'll Ever Need?

The video discusses the shift in operating system control, moving from rigid, centralized defaults to highly customizable, agent-driven environments. While Omarchy (a Linux desktop) exemplifies this future, the core lesson is that AI agents can modify existing Mac and Windows OS settings by interacting with documented, exposed APIs and configuration files. The key to successful agent implementation is scoping changes narrowly, defining specific inputs/outputs, and carefully managing permission levels to maintain system dependability.

Key takeaways

  1. Agent-Driven OS Customization

    Operating systems are fundamentally collections of decisions made by others. AI agents, like those demonstrated by Omarchy, allow users to 'time travel' and modify these decisions to fit highly specific, individual needs, rather than relying on universal defaults.

  2. Scoping Changes and Permissions 5:00

    When requesting changes, users must be highly specific (e.g., 'Find this setting, tell me the file that needs to change') rather than vague (e.g., 'Make it better'). Agents should only request the minimum necessary permissions, and the system must provide mechanisms to test and undo changes.

  3. The Wrapper Pattern

    A useful pattern is to build an agent wrapper around an existing, functional tool (like using Omaport with Arclone). This allows the agent to create a new, personalized experience without needing to reinvent the complex underlying functionality.

  4. Local Control vs. Processing

    It is crucial to distinguish between local control over an application and local processing of data. Users must be mindful that an agent running on a local machine may still send requests to external, cloud-hosted models.

Watch on YouTube Full article

Score Every Production Trace with an LLM Judge, from Your Terminal (LangSmith CLI) thumbnail

· 5:08

Score Every Production Trace with an LLM Judge, from Your Terminal (LangSmith CLI)

This walkthrough demonstrates how to implement automated, large-scale evaluation of AI agents using an LLM-as-a-judge within LangSmith. By setting up an online evaluation, developers can programmatically score incoming chat traces (e.g., checking for user frustration) without manually reviewing thousands of interactions. The process involves using a coding agent to install LangSmith skills and configure the evaluation, followed by managing the sampling rate to control costs.

Key takeaways

  1. Online LLM-as-a-Judge Setup

    Online evaluations allow an LLM to automatically score incoming agent traces based on a defined prompt and rubric (e.g., detecting user frustration). The output is a score and reasoning attached directly to the trace.

  2. Using LangSmith CLI for Automation 0:01

    A coding agent can be instructed to use the LangSmith CLI to create and manage the LLM judge evaluator, automating the setup process.

  3. Cost Management via Sampling Rate 0:04

    The sampling rate can be updated (e.g., from 100% to 50%) to reduce evaluation costs while maintaining continuous monitoring.

Watch on YouTube Full article

Your agents lack context: Here's how to fix "You're absolutely right!" — Brandon Waselnuk, Unblocked thumbnail

· 14:09

Your agents lack context: Here's how to fix "You're absolutely right!" — Brandon Waselnuk, Unblocked

AI agents require more than just access to information; they need a 'context engine' to achieve true understanding of a company's operations, business logic, and historical decisions. The talk details how agents fail when they lack deep, organizational context, leading to wasted tokens and time. The solution involves building a context engine that ingests data from disparate sources (e.g., ticketing systems, code repos) and provides structured, conflict-resolved context to the model in a token-optimized manner.

Key takeaways

  1. The Context Gap

    AI-generated code must feel like it was written by a long-term team member, which requires deep operational context that current agents lack. This gap compounds as agents scale from simple tab completion to background processes.

  2. Failure Modes of Context 7:00

    Common approaches like the 'curated context trap' (where documentation rots) and the 'MCP plateau' (where agents suffer from satisfaction of search bias) fail because access to information is not the same as understanding it.

  3. The Role of the Context Engine 9:12

    A proper context engine must perform conflict resolution (e.g., resolving conflicting architecture diagrams vs. Slack messages), respect permissions (OAuth/SSO), and deliver context in a token-optimized way.

  4. Efficiency Gains 13:00

    Implementing a context engine can lead to significant efficiency gains, demonstrated by a reduction from 21 million to 10.8 million tokens and a two-hour reduction in wall-clock time for the same task.

Watch on YouTube Full article

500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents — Ajay Prakash, LinkedIn thumbnail

· 20:25

500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents — Ajay Prakash, LinkedIn

LinkedIn addressed the challenge of coding agents (LLMs) lacking context within massive, proprietary enterprise codebases. The solution involves 'contextual agent playbooks and tools' managed by an internal MCP (Model Context Platform) server. Instead of feeding all tools into the context, the system uses three meta-tools—Search, Get Schema, and Execute—to scale to thousands of tools and playbooks. Playbooks provide self-contained, structured instructions, enabling agents to perform complex, multi-step tasks reliably, and incorporating a self-improving loop where agents update stale documentation.

Key takeaways

  1. Focus on Reliability and Quality from Day One 20:00

    The system's success was predicated on prioritizing quality and reliability over mere productivity, ensuring the infrastructure does not degrade as the organization scales its use of AI agents.

  2. Build Dedicated Infrastructure for Agents 20:10

    In a large enterprise, simply providing the latest AI models and tools is insufficient; a dedicated, robust infrastructure is required to manage and guide agent operations within the internal system context.

Watch on YouTube Full article

Multiplayer AI Manifesto thumbnail

· 13:29

Multiplayer AI Manifesto

The video outlines a 'Multiplayer AI Manifesto,' detailing the necessary shift from siloed, single-user AI chats to collaborative, cloud-native agent sessions. This transition is driven by the need for true co-working experiences that eliminate context switching and data fragmentation (the 'context task tax'). The manifesto proposes five core principles—such as agents living next to the work surface and keeping learning open—to guide the development of highly productive, secure, and collaborative AI workflows.

Key takeaways

  1. The Need for Multiplayer AI

    Current single-player AI chats force users into a 'context task' workflow (e.g., copying code from GitHub to Claude, then pasting it to Slack). Multiplayer agents allow co-workers to interact with the same agent session simultaneously, eliminating this friction.

  2. The Five Principles of Multiplayer AI

    1. **Refuse to Copy and Paste:** Agents must live directly next to the work surface (e.g., in Notion or GitHub) rather than within a separate chat window. The agent must access all tools available to the human team. 2. **Work with the Door Open:** Collaboration requires open learning, where best practices and insights are shared publicly, accelerating collective knowledge gain (analogous to Shopify's 'River' system). 3. **Continuously Improve:** Learning from successful prompts or complex iterations should be automatically codified as a skill for the agent. 4. **People are not Routers; Agents are:** Humans must focus on high-value activities, while agents handle routing and answering repetitive project update questions. 5. **Nothing Starts from Scratch:** The entire agent session that generated an artifact (document, PR) must persist in the cloud to ensure continuity for team members.

  3. Technical Requirements & Security

    AI agents must reside entirely in the cloud and be managed by a robust boundary. This is crucial because local/laptop agents are insecure, cannot be preserved long-term, and prevent team access. Furthermore, strict governance (a 'black box' record) is required to track what data an agent accesses and which users interact with it.

Watch on YouTube Full article

Inside the Team That Killed Mandatory Code Review — Quinn Slack, AMP thumbnail

· 40:14

Inside the Team That Killed Mandatory Code Review — Quinn Slack, AMP

The discussion outlines a paradigm shift in software development driven by AI agents, moving away from traditional local development environments and mandatory code reviews. The core argument is that cloud-based agent execution (via platforms like AMP/Orbs) enables unprecedented parallelism and efficiency, making older methods obsolete. This transition requires rethinking infrastructure, security models (e.g., using limited OIDC access instead of unfettered laptop access), and even version control systems.

Key takeaways

  1. The Obsolescence of Local Development 17:22

    Local development is becoming outdated because cloud-based agents (like those running in Orbs) allow for massive parallelization, enabling developers to run many tasks simultaneously without the friction or limitations of a local machine. The speaker notes that this shift benefits both developer experience and security.

  2. The Decline of Mandatory Code Review 21:42

    Speakers claim that mandatory code review is 'dead' for modern, agent-driven workflows. This change is attributed to the high trust and accountability built into small, highly skilled teams using agents, allowing fixes to be deployed rapidly (e.g., 15 minutes after detection) rather than waiting days.

  3. The Rise of 'Jellyware' and Mini-Apps 28:00

    Software is moving toward highly customizable, forkable mini-apps (or 'jellyware') rather than monolithic packages with fixed settings screens. Agents are positioned as the ultimate configuration layer for any software.

  4. Cloud Infrastructure is Key to Agent Security 30:30

    Running agents in a controlled cloud environment (like Orbs) is argued to be significantly more secure than running them on an unmanaged developer laptop, which can grant unfettered access and pose security risks.

Watch on YouTube Full article

AI Simplified: 6 Concepts You Need to Know About Modern AI thumbnail

· 8:49

AI Simplified: 6 Concepts You Need to Know About Modern AI

The video simplifies modern AI by detailing six essential concepts: Large Language Models (LLMs), Model Training/Tuning, Retrieval Augmented Generation (RAG), AI Agents, Model Context Protocol (MCP), and System Prompts. The explanation uses human analogies to show how these components—from the core 'brain' (LLM) to the 'central nervous system' (MCP)—are integrated to create sophisticated systems capable of reasoning, accessing external knowledge, and taking autonomous actions.

Key takeaways

  1. Artificial Intelligence (AI)

    A subfield of computer science focused on matching or exceeding human intelligence in a machine. The core function is generating content using probabilities to predict output based on input, described as 'autocomplete on steroids.'

  2. Large Language Models (LLMs)

    The foundational component or 'brain' of the AI system where core intelligence and reasoning capabilities reside. It is responsible for generative AI outputs (words, images, sounds).

  3. RAG (Retrieval Augmented Generation) 3:35

    A method to extend the LLM's knowledge base by integrating trusted external sources (e.g., research papers or product documentation). This process helps reduce 'hallucinations'—confident errors made by the AI.

  4. AI Agents 5:20

    An advanced system where a model autonomously uses external tools (e.g., writing code, searching the web, reading/writing databases) to achieve specific goals, giving the AI 'hands and feet.'

  5. Model Context Protocol (MCP) 6:20

    The orchestration layer that acts as the central nervous system for an AI agent. MCP connects the model's reasoning to the external tools, coordinating actions.

  6. System Prompts 7:30

    A set of guiding principles or constraints given to the model that dictates its behavior and ethical boundaries. This prevents misuse (like prompt injections) without requiring constant, expensive retraining.

Watch on YouTube Full article

NVIDIA, Docker & Hud on Agents in Production thumbnail

· 10:04

NVIDIA, Docker & Hud on Agents in Production

The discussion explores the operational challenges of deploying AI agents in a production environment (24/7 operation). Key insights emphasize that successful agent deployment requires shifting focus from root cause analysis to comprehensive context and observability. Speakers covered topics including using agents with combined data sources (Elastic logs + ServiceNow), redesigning automated fixes for human consumption, optimizing GPU utilization during tool calls, and leveraging AI-built tracing frameworks for debugging rare bugs.

Key takeaways

  1. Context over Root Cause Analysis 2:10

    When agents are running 24/7 in production, the most critical resource is context—understanding what changed yesterday and the relationships between services. This proactive data knowledge is more valuable than traditional root cause analysis.

  2. Automated Fixes Must Convince Humans 5:40

    Simply automating investigations and opening pull requests (PRs) for high-impact fixes is insufficient, as developers often ignore them. The output must be rebuilt to convince the human developer of its value and priority.

  3. GPU Idle Time During Tool Calls 7:10

    A counterintuitive finding is that when an agent makes a tool call, the GPU sits idle. Properly accounting for this CPU-intensive period allows users to serve roughly twice as many users compared to benchmark predictions that ignore tool calls.

  4. AI-Built Tracing Frameworks 9:00

    For debugging rare bugs, the most useful investment is getting AI to build a tracing framework. Providing traces from an overnight run allows the agent to pinpoint the exact problem rather than guessing or failing to reproduce the issue.

Watch on YouTube Full article

From coding to Knowledge work agents — Karan Vaidya, Composio thumbnail

· 20:42

From coding to Knowledge work agents — Karan Vaidya, Composio

The presentation argues that while autonomous AI agents have excelled in software engineering due to inherent infrastructure support (e.g., Git history, CI/CD), knowledge work agents are currently limited because they lack comparable foundational systems. The speaker identifies six critical primitives—Centralization, History, Context, Verification, Governance, and Reversibility—that must be built into the enterprise layer to enable reliable AI agents for fields like sales and support.

Key takeaways

  1. The Infrastructure Gap

    Coding agents benefit from infrastructure (repo, commit history, tests, CI/CD) that was designed for automation. Knowledge work lacks this surrounding system, causing agents to operate 'blind' when applied outside of code bases.

  2. Centralization is Key 3:55

    Knowledge work data is typically scattered across multiple platforms (e.g., Salesforce, Notion, Gmail, Slack). Agents require a single source of truth—a centralized layer—to pull all necessary threads and connections before they can operate effectively.

  3. The Six Missing Primitives

    To bridge the gap between coding agents and knowledge work agents, six primitives must be built: Centralization (single data source), History (record of past actions), Context (organizational map + style guide), Verification (pre-action checks), Governance (deterministic boundaries/walls), and Reversibility (undo capability).

  4. Failure is Permanent in Knowledge Work 20:00

    Unlike code, where changes can be reverted or walked back, many knowledge work actions (sent emails, wire transfers) are irreversible. This shifts the risk profile, requiring agents to check their work *before* executing any destructive action.

Watch on YouTube Full article

GitHub Next & Tessl on the Self-Merging Repo thumbnail

· 10:36

GitHub Next & Tessl on the Self-Merging Repo

The discussion outlines the evolution of software development from traditional CI/CD to a new paradigm: Continuous AI. Speakers presented models where automated agents handle code improvements, testing, and merging (Paul Stack). Key shifts include viewing continuous improvement as a system-level problem rather than an individual productivity issue (Don Syme), prioritizing fixing the build system over fixing the code itself (Patrick Debois), and leveraging advanced AI tools for knowledge retrieval and proactive information gathering (Robert Overweg).

Key takeaways

  1. Continuous AI is the Third Pillar 0:20

    The development process requires three pillars: Continuous Integration (CI), Continuous Deployment (CD), and continuous AI, which focuses on automated code improvement in the repository.

  2. Agent-Driven Merging Process 2:33

    Advanced pipelines allow agents to open a pull request, pass multiple reviews/gates, push changes, and auto-merge upon successful completion. The UAT (User Acceptance Testing) gate remains critical for preventing regressions before end-user release.

  3. Focus on System Improvement 8:07

    The primary mistake is fixing the code when an agent fails; the correct approach is improving the system that produced the faulty code. This shifts focus from 'fix the code' to 'fix the system.'

  4. Knowledge Retrieval and Briefing 9:20

    AI agents can transform company knowledge into a searchable resource, allowing users to query complex information in plain language or receive daily briefings rather than managing a backlog.

Watch on YouTube Full article

850 PRs a Week: How Tessl Runs a Software Factory thumbnail

· 51:18

850 PRs a Week: How Tessl Runs a Software Factory

The video outlines the concept of a 'Software Factory'—a modern development paradigm where most work is managed by self-improving AI agents. This factory model progresses from defining foundational standards (Skills) to creating automated, iterative workflows (Loops), culminating in full automation. Key insights emphasize that success requires prioritizing context engineering and standardization over raw speed, as the primary gains are increased code quality and functional fungibility across teams.

Key takeaways

  1. The Factory's True Gains 11:57

    Increased capacity does not solely lead to feature velocity; two major benefits observed are an increase in overall code quality (e.g., fixing consistency, copy, and brand voice) and improved fungibility, allowing non-engineering teams (like GTM) to make high-leverage changes without waiting on support.

  2. Context Precedes Automation 13:56

    The core principle is that before automating a process, one must first define 'what correct looks like.' This context definition serves as the manual for operating the company and is critical for building resilient, scalable agents.

  3. Skills $\rightarrow$ Loops $\rightarrow$ Factory 6:10

    The factory model is a continuum: Skills are defined units of work or policies; Loops are automated skills that improve with each run (compounding gains); and the Factory is the system where most development effort shifts to maintaining and improving these loops.

  4. Enforcing Standards: Verifiers and Evals 27:20

    To ensure quality at scale, systems must implement verifiers (generating LLM-judge tools from skills) and evals. These mechanisms enforce standards in CI/CD pipelines, moving code review checks 'left' into the development process.

Watch on YouTube Full article

Agentic approaches to processing long videos with Gemini thumbnail

· 1:31

Agentic approaches to processing long videos with Gemini

Agentic video understanding with Gemini allows developers to process long-form videos without submitting the entire content, which could exceed 100,000 tokens. Instead, the model uses an agentic loop (thinking, acting, observing) and specialized tools—such as `get transcript`, `get frames`, and audio extraction—to iteratively zoom in on relevant information, significantly reducing token usage and improving processing performance.

Key takeaways

  1. Token Efficiency

    By using an agentic approach, the model avoids submitting the entire video content (which can exceed 100,000 tokens), leading to massive token reductions and lower latency.

  2. Agentic Workflow

    The process involves the model first determining necessary tools (e.g., `get transcripts`, `get frames`) before executing a traditional agentic loop of thinking, acting, observing, and iterating until the answer is derived.

  3. Targeted Analysis

    This technique improves performance by allowing the model to 'zoom in' on specific functions or segments within the video that are most relevant to the query, rather than processing all data equally.

Watch on YouTube Full article

Agent Spending Without Controls — Rodrigo Coelho & Pranav Maheshwari, Edge & Node thumbnail

· 20:48

Agent Spending Without Controls — Rodrigo Coelho & Pranav Maheshwari, Edge & Node

The video outlines the critical need for a dedicated infrastructure layer—specifically focusing on micropayments and compliance controls—to enable agentic commerce. While Large Language Models (LLMs) and agents can transact at machine speed, traditional payment rails were designed for human decision loops. The speaker argues that as AI agents become more powerful through paid Machine Capability Platforms (MCPs), the system must incorporate robust compliance layers to handle sanctions screening and prevent overspending, making governance a prerequisite for enterprise adoption.

Key takeaways

  1. Agentic Payments Require Paid Infrastructure 5:15

    Agents are becoming increasingly powerful by utilizing specialized, often paid, MCP servers. The speaker argues that relying on free services is unsustainable; agents require an aggregator/skill file (like Ampersend) to manage payments in the background, enabling transactions with a payment gateway.

  2. Traditional Rails Fail at Machine Speed 7:00

    Existing financial systems assume a human 'in the loop' for decision-making. Agents transact around the clock at machine speed, necessitating new protocols that can handle high-volume, automated payments and compliance checks.

  3. Compliance is the Enterprise Bottleneck 9:02

    For large enterprises to adopt agentic systems (handling trillions of dollars), a mandatory compliance layer must be implemented. This layer verifies counterparty identity, screens for sanctions, and prevents malicious transactions, which is currently lacking in automated agent workflows.

Watch on YouTube Full article

When AI Agents Pay and Sellers Monetize: Building x402 Apps on AWS — Anil Nadiminti, AWS thumbnail

· 20:41

When AI Agents Pay and Sellers Monetize: Building x402 Apps on AWS — Anil Nadiminti, AWS

The shift to autonomous AI agents is creating a new e-commerce paradigm where content access requires programmatic payment rather than human intervention. The talk outlines solutions for both sides: the buy side (agents needing secure wallets and microtransaction capabilities) and the sell side (publishers monetizing high volumes of bot traffic). Key innovations include AgentCore Payments, which enables agents to execute payments using protocols like X42, and AWS WAF features that allow publishers to classify, verify, and monetize AI-driven traffic at the edge without changing origin infrastructure.

Key takeaways

  1. The Shift from Human to Machine Payments

    Traditional subscription models fail when autonomous agents encounter paywalls. The industry is moving from a 'human in the loop' process (manual payments) to an automated, programmatic payment credential model.

  2. The X42 Protocol for Microtransactions 10:36

    X42 is a protocol designed for machine-to-machine transactions, allowing content access via payment authorization (status code 402). It supports microcent payments and operates at internet speed without centralized friction or API key setup.

  3. AgentCore Payments for Buy Side Security 15:23

    AWS AgentCore Payments provides AI agents with wallet support, payment connectors (e.g., Coinbase, Stripe), and critical guardrails like per-session spending limits and expiry times. Imported wallet keys are stored in a KMS-backed store, ensuring the agent cannot access private keys.

  4. Edge Monetization for Sell Side Revenue 20:12

    Publishers can monetize AI traffic using AWS WAF bot detection (identifying over 650 bot types) and intent analysis. This allows pricing based on path, verified bot signature, or whether the request is for training versus search.

Watch on YouTube Full article

Why Your AI Agent Needs a Wallet: USDC and Nanopayments — Harshal Bhangale, Circle thumbnail

· 20:52

Why Your AI Agent Needs a Wallet: USDC and Nanopayments — Harshal Bhangale, Circle

The primary bottleneck for advanced AI agents is not model capability but payment infrastructure. Agents require real-time, low-cost mechanisms to pay for data and compute resources (microtransactions). Traditional credit card rails fail due to unsustainable fees on high-frequency, fractional payments. Circle addresses this by implementing a specialized agent stack using USDC and Nano Payments, which facilitates off-chain authorization and sub-second settlement, allowing autonomous agents to function seamlessly in the 'agentic economy.'

Key takeaways

  1. The Payment Bottleneck for AI Agents

    AI agent capability often halts when it encounters a paywall or needs to transact. The core argument is that agents consume resources (data, compute) in fractional amounts at high frequency, making traditional payment rails unsustainable.

  2. Agentic Economy Signals 4:13

    The agentic economy is progressing from simple prompts to complex workflows. In the last 30 days, agents have transacted $24 million against paid API endpoints over X102, with nearly all funds settled in USDC.

  3. The Need for Specialized Payments 7:28

    Traditional payment schemes were built for human-to-human transactions. Agents require payments that are real-time, low cost, and programmable to handle microtransactions (e.g., paying 10 cents for a specific data subset).

  4. Nano Payments Infrastructure 12:30

    To overcome blockchain latency and gas fees on small transactions, the solution uses Nano Payments: funds are deposited into a smart contract, the agent signs off-chain cryptographic authorizations, and the server relays this confirmation within milliseconds.

Watch on YouTube Full article

You Never Told Your Agent What Done Means. It Decided For You. thumbnail

· 27:09

You Never Told Your Agent What Done Means. It Decided For You.

AI agents are capable of sophisticated work, but their utility hinges entirely on defining 'what done means.' The primary risk is that agents optimize for process or passing an evaluation score rather than achieving measurable business outcomes. Successful deployment requires establishing clear, verifiable standards—such as those used in code reviews (e.g., cyclomatic complexity) and linking agent actions directly to existing business metrics (e.g., speed to lead).

Key takeaways

  1. Define the Passing Condition

    If you cannot clearly define what 'done' means for an agent, you are buying process rather than value. The passing condition must represent a tangible business result that the company actually cares about.

  2. The Danger of Process Over Product

    Agents can become highly skilled at finding ways to pass tests (like in the Hugging Face incident), leading them to generate complex reports or code that improves metrics without improving the underlying business system. The goal must be meaningful work, not just activity.

  3. The 'Second Best Engineer' Test

    A critical measure of agent-generated knowledge work is whether an ordinary, competent engineer (not the top expert) can inspect and explain the code or document created by the agent. This ensures long-term maintainability.

  4. The Unplug Test

    Before deployment, perform an 'unplug test': remove the agent to determine if meaningful business work (e.g., triaging support tickets, maintaining release cadence) would stop happening. If only process stops, the agent is not providing value.

Watch on YouTube Full article

Why Does AI Need Access to the Web? thumbnail

· 19:03

Why Does AI Need Access to the Web?

Large Language Models (LLMs) are inherently limited because they operate as pre-trained snapshots, meaning their knowledge freezes after training and cannot account for real-time changes in the world. To build reliable AI agents that function in dynamic environments, the system must incorporate a robust Knowledge Layer fed by a specialized Web Data Infrastructure Layer. This infrastructure is necessary to provide fresh, structured, and trustworthy web data at inference time, thereby eliminating 'Garbage In, Garbage Out' (GIGO) errors.

Key takeaways

  1. LLMs are Static Snapshots 0:25

    Pre-trained LLMs only contain knowledge up to their training cutoff date. When released, they cannot account for new products, laws, or daily news events, leading to potential hallucinations [0:25].

  2. AI Agents Require Real-Time Context 1:30

    Unlike humans who can recognize and ignore incorrect information, AI agents act on all received data. If they receive outdated or fabricated information, the consequences can be costly and happen at scale [1:30].

  3. The Solution: Knowledge Layer & Web Data Infrastructure 2:20

    The most impactful leap in AI functionality is connecting models to a live context via a robust knowledge layer. This layer must receive fresh, reliable data from the web through a specialized web data infrastructure [3:25].

Watch on YouTube Full article

Tribal Dungeons of Global Shipping: AI Agents at Global Scale — Dmitry Buykin, Maersk thumbnail

· 12:02

Tribal Dungeons of Global Shipping: AI Agents at Global Scale — Dmitry Buykin, Maersk

This report details the engineering challenges of operationalizing complex, global business processes using AI agents. The core challenge is translating 'tribal knowledge'—which exists as unstructured Standard Operating Procedures (SOPs) or screenshots—into executable agent workflows. The speaker emphasizes that the system is not the agent loop itself, but rather the surrounding 'refining loop.' This loop involves building robust mechanisms for validation, error handling, and systematic improvement, which requires capturing a vast SOP corpus (estimated 20:1 ratio to runtime).

Key takeaways

  1. The Long Tail Problem

    While happy paths are often automated, the most expensive part of global operations is the 'long tail'—the exceptions and variations that require expert orchestration across multiple incomplete systems.

  2. Agent vs. Expert Knowledge

    SOPs explain what a person sees and clicks (screenshots), but an agent SOP requires complex setup: preconditions, decisions, identifiers, backend calls, validation, recovery, and evidence of successful execution. Experts own the 'what,' and agents own the 'how.'

  3. The Refining Loop is the System 3:34

    The true system is not the agent loop but the surrounding refining loop. This process requires making corrections executable changes, establishing guardrails to prevent unsafe paths, and ensuring behavior is observable.

  4. Scaling Improvement

    Accuracy was not designed upfront; it was earned through systematic effort. The team logged over 100,000 corrections over nine months, using heat maps to prioritize the most beneficial work for experts and engineers.

  5. The Goal of AI Native Operation

    AI native operation is not just about agents in a workflow; it's an adaptive architecture that learns from successful scenarios, aggregates them into composite tools, and allows repeatable rollouts across hundreds of countries.

Watch on YouTube Full article