Channel

AI Engineer

Digests from AI Engineer

Agents' next frontier: agent-to-agent and network effects — Jean-Denis Greze, Town thumbnail

· 21:17

Agents' next frontier: agent-to-agent and network effects — Jean-Denis Greze, Town

The talk reframes multi-agent systems not as 'agent-to-agent' interactions, but fundamentally as a search problem: ensuring that an LLM's context window contains the optimal information for a tool call. The primary technical barrier to achieving this ideal state—a single agent with access to all world information—is not context length, but privacy and security. Greze outlines five strategies (Shared Trust Boundaries, Custom Tools, Shared Silos, Human Conduit, Black Box) that attempt to approximate the optimal outcome while managing data leakage risks.

Key takeaways

  1. Reframing Agents as Search Problems 2:00

    Most LLM systems are best viewed as search problems. The goal is engineering the system so that the context window contains the precise information needed before a tool call, maximizing the LLM's ability to return the best result.

  2. The Privacy Constraint (Coase Theorem) 5:24

    The ideal state is one agent with access to all world information. However, privacy acts as a transaction cost, preventing this perfect data aggregation, which the Coase theorem highlights.

  3. Shared Silos and Sweeper Agents 13:59

    A promising approach is creating shared silos (e.g., wikis) where a 'sweeper AI' automatically identifies and moves information from private spaces into public, company-wide knowledge bases.

  4. The Black Box Approach

    This advanced method allows an LLM (in a 'black box' agent) to query multiple silos without pinging every human. It only asks the data owners for approval at the final moment of information sharing.

  5. The Future: Auto Mode

    The frontier is 'auto mode,' where LLMs are trusted to automatically determine if a disclosure is low-sensitivity and can be shared without explicit human approval, scaling with model capacity.

Watch on YouTube Full article

Tethered: Our Agents Are Us — Shu Fang, Two Sigma thumbnail

· 21:10

Tethered: Our Agents Are Us — Shu Fang, Two Sigma

Two Sigma implemented a framework allowing every employee to run cloud agents using their own unique user identity, addressing the challenges of permissions drift and maintaining security in a highly regulated environment. The solution leverages existing Kubernetes infrastructure (dedicated namespaces per person) and introduces two critical guardrails: propagating a trace header for full action provenance, and utilizing Google's web grounding for enterprise—a restricted search index that eliminates external egress vulnerabilities while accepting a data freshness constraint of up to 24 hours.

Key takeaways

  1. Running Agents as User Identity 2:00

    By running agents with the user's exact identity, the system bypasses conventional constraints like permissions drift and licensing issues associated with separate machine identities. This capability was supported by pre-existing infrastructure: a Kubernetes namespace per individual in every region, where automated jobs already ran using the user's identity via a sidecar mounting mechanism.

  2. Ensuring Action Provenance (Attribution) 8:37

    To differentiate between actions taken by the human and those performed by the agent, a dedicated header is propagated throughout the system. This trace ID allows for full provenance tracking, enabling the replay of the entire chain of actions leading to an end result, which is superior to simple identity verification.

  3. Securing Web Access with Grounding 9:18

    To mitigate risks like exfiltration and prompt injection from open web access, the firm adopted Google's 'web grounding for enterprise.' This service provides search and fetch capabilities within the internal VPC network boundary, while blocking native tools (e.g., Brave web browser) to ensure all requests route through the controlled index.

Watch on YouTube Full article

Everyone Gets A Software Company — Benjamin Guo, Zo Computer thumbnail

· 15:09

Everyone Gets A Software Company — Benjamin Guo, Zo Computer

Ben Guo of Zo Computer argues that current software architecture leads to 'technofeudalism,' where users are dependent on rented services (SaaS and cloud providers) and lack data ownership. He introduces Zo, a personal cloud server with integrated AI, designed to give individuals and small businesses full ownership over their digital presence and data. The platform allows for self-hosting of websites, APIs, and applications, enabling non-technical users to manage complex operations—such as invoicing, scheduling, and e-commerce—from a single, owned source.

Key takeaways

  1. Technofeudalism in Software 5:26

    The current model involves paying subscriptions (rent) up the stack (SaaS providers -> cloud providers -> chip manufacturers), leading to data silos and lack of user control. This structure is termed 'technofeudalism' (3:26).

  2. Zo as a Personal Cloud Solution 8:22

    Zo provides an owned, personal cloud environment where users can host all services (websites, APIs) and integrate AI tools. This contrasts with relying on fragmented SaaS stacks (5:02).

  3. Empowering Non-Developers 11:52

    Case studies show that non-technical users, like Charlotte and Anthia, can replace multiple costly SaaS subscriptions (e.g., Squarespace, Calendly) with Zo, maintaining full control over their data and revenue streams (7:12).

  4. Future of AI Agents

    Guo predicts that future interactions will primarily involve agents in the cloud. He warns against 'intelligence feudalism,' where agent intelligence accumulates within proprietary, company-level clouds (like Claude), advocating for a model where individuals and companies own and self-improve their published agents (11:57).

Watch on YouTube Full article

Beyond the Lethal Trifecta: Agentic Commerce on the Open Internet — David Levine, Kiduna Club thumbnail

· 21:40

Beyond the Lethal Trifecta: Agentic Commerce on the Open Internet — David Levine, Kiduna Club

The presentation outlines the concept of 'agentic commerce'—a full economy on the open internet powered by autonomous agents. The speaker argues that current platforms are extractive and limited by the 'lethal trifecta': private data, untrusted content, and agent ability to act (3:54). To solve this, he proposes using decentralized legal structures like DUNA (Decentralized Unincorporated Nonprofit Association) for organizational standing and cryptographic tokens (JWTs) for verifiable identity. He details how agents can be built as software-defined organizations ('Kiduna'), enabling them to own assets, enter agreements, and operate with full auditability on the blockchain.

Key takeaways

  1. The Lethal Trifecta 6:34

    The combination of private data (e.g., bank info, logins), untrusted content from the open internet, and agents' ability to take actions is what currently prevents true agentic commerce (3:54).

  2. DUNA Legal Standing 8:10

    A DUNA (Decentralized Unincorporated Nonprofit Association) provides legal standing for an organization composed of intelligent agents, allowing it to own property, enter agreements, and raise capital without distributing profits as securities (4:50).

  3. Agentic Identity via JWTs 11:45

    Agents establish identity, authority, and boundaries using cryptographic tokens like JWTs. This allows the organization's registration (e.g., with a Secretary of State) to act as a verifiable domain name system for agents, providing an audit trail on the blockchain (6:39).

  4. Governance via Decision Markets 13:30

    Instead of traditional voting, organizations should use 'decision markets' (similar to prediction markets) where members trade pass/fail tokens on proposed policies. This method is argued to lead to better decisions by aligning agents with a shared purpose and value system (8:10).

Watch on YouTube Full article

The End of the Static Screen: Architecting Intent-Driven UX — Gus Iwanaga, commercetools thumbnail

· 23:19

The End of the Static Screen: Architecting Intent-Driven UX — Gus Iwanaga, commercetools

The presentation outlines a shift from static, complex SaaS UIs to dynamic, intent-driven experiences using generative UI protocols. The core architecture involves an orchestrator that classifies user intent and calls tools, which then map results onto eligible components defined in a component catalog. This process generates a structured UI specification (UI spec) that ensures the final output adheres strictly to the design system, mitigating the unpredictability inherent in pure LLM-generated markup.

Key takeaways

  1. The Failure of Pure Generative Output 11:40

    Relying solely on an LLM to compose an entire experience (e.g., generating a sales report) leads to inconsistency, such as varying date ranges or KPI card layouts for the same query (7:00). The speaker asserts that this non-deterministic output is unsuitable for production.

  2. The Declarative Middle Ground 18:55

    A robust approach requires an orchestrator to classify intent, invoke tools (first or third party), and then generate a UI spec. This spec dictates the placement of components from a catalog, ensuring the final output is compliant with the design system every time.

  3. The Importance of Hierarchy (Atomic Design)

    To maintain control over layout and arrangement—a critical aspect of UX—the architecture must invert the traditional hierarchy: components map to sub-slots, which map to slots, which finally map to templates. This codifies UX knowledge into the agent.

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

x402 isn’t good (yet) — Jan Curn, Apify thumbnail

· 20:48

x402 isn’t good (yet) — Jan Curn, Apify

The talk critiques current standards for agentic payments, arguing that while protocols like x402 are exciting, they suffer from significant architectural flaws, particularly regarding double spending and standardization conflicts. The speaker highlights the rapid proliferation of payment standards (L402, MasterCard Agent Pay, etc.) and proposes solutions such as batch settlement and a new 'Agent General Interface' (AGI) to facilitate robust, flexible agent-to-agent commerce.

Key takeaways

  1. x402 Status Code Flaws 7:59

    The x402 protocol requires the server to respond with HTTP 402 Payment Required. This conflicts with other standards (like MCP requiring 401), forcing companies to create dedicated hostnames for payments, which the speaker calls an anti-pattern.

  2. The Double Spending Window 10:19

    A critical vulnerability in current payment flows is that until a transaction settles on the blockchain, the buyer can use the same funds for multiple transactions (double spending). This risk makes non-trivial work difficult to guarantee.

  3. Need for Flexible Interfaces 17:15

    To avoid creating new endpoints or rigid API changes, the speaker introduced AGI (Agent General Interface), a simple markdown document designed for agents rather than humans. This allows services to adapt quickly without requiring strict backward compatibility.

Watch on YouTube Full article

Your Agent Just Authorized What?! — Jay Mok & Ben Coumes, Paypal thumbnail

· 16:07

Your Agent Just Authorized What?! — Jay Mok & Ben Coumes, Paypal

The talk outlines a framework for agent authorization in payments, arguing that security requirements depend entirely on the context: specifically, the stakes and whether the transacting parties are known to each other. The discussion moves from low-stakes scenarios (e.g., coding agents using tool permissions) to high-stakes autonomous transactions with unknown counterparties. Solutions include leveraging OAuth scopes for controlled authority in medium-stakes environments, or implementing advanced primitives like layered selective disclosure JWTs and the PayPal approval token to verify mandates autonomously.

Key takeaways

  1. The Three Authorization Questions 0:01

    Any agent authorization system must answer: 1) Did the human authorize this? (e.g., passkey); 2) Is it allowed right now in this scope? (e.g., time-bound token, amount, merchant); and 3) Can we prove it later? (Dispute resolution proof).

  2. Stakes vs. Counterparties Matrix 0:02

    The required security model changes based on context: Low stakes (coding agents) rely on system logs and reversibility; Medium stakes (shared vaults/OAuth scopes) use controlled mandates; High stakes (never-met counterparties) require verifiable proof.

  3. High Stakes Solution 0:10

    For autonomous payments between unknown parties, the industry should converge on a multi-layered selective disclosure JWT. This allows merchants and processors to verify their specific mandate without knowing each other's relationship.

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

Multimodal Collaborative Agents for Next-Gen Commerce — Nidhi Kaushik Vyas, Google DeepMind thumbnail

· 21:08

Multimodal Collaborative Agents for Next-Gen Commerce — Nidhi Kaushik Vyas, Google DeepMind

The talk outlines a framework for multimodal collaborative agents designed to handle 'fuzzy intent' in commerce and consumer verticals. Instead of acting as simple search bar wrappers that assume well-defined user goals, these advanced agents proactively guide users who arrive with only a 'vibe.' The core mechanism is a three-stage loop—Discovery, Research, and Response—which systematically builds a working state from multimodal inputs (images, context) to determine the optimal next question or presentation format.

Key takeaways

  1. Handling Fuzzy Intent 1:48

    Agents must address the 'articulation gap,' recognizing that users often arrive with vague preferences rather than precise keywords. The agent's role is to proactively elicit and refine these fuzzy intents.

  2. The Collaborative Loop 3:23

    The system operates in a loop: Discovery (building the working state), Research (determining the best way to ask/find information), and Response (adapting the output format).

  3. Prioritizing Information Gain 13:41

    The agent must calculate which unknown variable, when queried, will yield the 'maximal information gain' to move the conversation forward efficiently (e.g., determining room width is critical before recommending furniture).

  4. Multimodal Elicitation 5:20

    For subjective preferences, visual inspiration boards and multimodal inputs are significantly more effective than text-based questioning for establishing a common language between the user and the system.

Watch on YouTube Full article

Teaching agents to pay — Anna Spysz, Stripe thumbnail

· 19:10

Teaching agents to pay — Anna Spysz, Stripe

This talk introduces 'agent-to-commerce,' detailing how AI agents can move beyond research assistance to execute complex transactions on behalf of users. The infrastructure relies heavily on structured data protocols like the Universal Commerce Protocol (UCP) and requires merchants to publish a `merchant capabilities manifest` and JSON catalogs, rather than relying on traditional website browsing. Security is maintained through shared payment tokens, ensuring that the payment provider—not the agent or merchant—enforces transaction limits and guardrails.

Key takeaways

  1. Agent Discovery vs. Human Browsing 5:13

    Agents do not browse websites; they read structured data (JSON) from a `merchant capabilities manifest` to understand supported payment methods, endpoints, and product catalogs. This makes merchants 'agent-ready.'

  2. The Role of UCP in Transactions 5:40

    The Universal Commerce Protocol (UCP) acts as a shared language defining how agents initiate, update, complete, and cancel purchases across multiple merchants and agents.

  3. Security via Shared Payment Tokens 13:46

    During checkout, the agent receives and passes a 'shared payment token' (representing a raw card number or wallet). The seller only unwraps what is necessary, and the payment provider enforces all limits, mitigating risk.

Watch on YouTube Full article

SOTA Generative Media Panel — Dumitru Erhan, Shane Gu & Nicole Brichtova, Google DeepMind thumbnail

· 56:59

SOTA Generative Media Panel — Dumitru Erhan, Shane Gu & Nicole Brichtova, Google DeepMind

The session provided an overview of SOTA generative media models, highlighting new APIs like NanoBanana 2 Lite and Gemini Omni Flash. Key architectural discussions centered on the limitations of language as a sole intermediate representation for complex sensory data (taste, smell, skin tone). The consensus points toward a future requiring unified 'World Models' that integrate visual, temporal, and symbolic reasoning, moving beyond single-modality generation. Evaluation remains highly dependent on human judgment, making robust testing and field feedback critical.

Key takeaways

  1. New APIs Launched for Developers 0:15

    Google launched NanoBanana 2 Lite (the fastest/cheapest image model in the family) and the Gemini Omni Flash APIs. The Omni Flash API enables video generation and editing, priced similarly to V3 fast, making it accessible for developers [0:15-0:40].

  2. Generative Media Capabilities 2:00

    Models can now take diverse inputs (e.g., a storyboard of images, an audio track) to generate video. Furthermore, natural language processing allows for advanced video editing tasks like adding or removing elements from existing footage [1:20-3:00].

  3. The Limitation of Language as Representation 1:50

    Speakers argued that language is an insufficient intermediate representation for highly sensitive sensory data (e.g., taste, smell, skin tone). This suggests a need for more foundational representations, potentially including code or direct binary/latent space conditioning [1:50-2:30].

  4. Evaluation Challenges and Reward Hacking 0:35

    While human preference often favors AI output (e.g., sharper, more saturated images), this metric is unreliable for optimization. External testers have found 'reward hacking' artifacts, such as the model consistently adding wedding rings to hands [0:35-0:45].

Watch on YouTube Full article

Tell the Robot What You Want — Sandhya Subramani, AWS thumbnail

· 17:23

Tell the Robot What You Want — Sandhya Subramani, AWS

The presentation demonstrates 'Scout,' a rover running on a Raspberry Pi, that has been upgraded from a traditionally programmed robot into an agentic system using AWS's open-source framework, `strands`. This architecture allows the robot to understand and execute complex commands in natural language (e.g., counting people or responding to arbitrary prompts) by having an AI agent orchestrate calls to existing hardware policies/tools. The system utilizes a multi-agent setup (thinker, communication, voice) and operates on a hybrid cloud/edge model for both training (VLA models) and fast runtime execution.

Key takeaways

  1. Agentic Robotics Architecture 2:07

    By implementing an agent layer above existing movement policies, the robot can perform tasks it was never explicitly trained for. The agent decides *what* to do, while the policy determines *how* to execute the action.

  2. Multi-Agent System Design 5:46

    Scout runs three simultaneous agents: a thinker (constantly assessing the environment), a communication agent (via Telegram/web app), and an optional voice agent, allowing for complex, concurrent decision-making.

  3. Hybrid Cloud/Edge Deployment 11:57

    The system is designed to operate on a hybrid model: training (VLA models) occurs in the cloud using `agentcore`, while execution and policy calls happen rapidly at the edge (on the robot's local hardware).

Watch on YouTube Full article

The Signal Layer: What to Build When Anything Can Be Built — Lena Hall, Akamai thumbnail

· 19:44

The Signal Layer: What to Build When Anything Can Be Built — Lena Hall, Akamai

In an era of 'drowning in abundance' where AI makes virtually anything technically buildable, the value has shifted from implementation speed to defining and protecting a unique signal. The talk introduces the concept of the 'signal layer,' which involves two parts: clearly defining your unique signal (the 'build side') and ensuring it survives transmission without distortion (the 'ship side'). Since broad taste is trainable by models, true differentiation requires judgment about unobserved relationships or future events—areas where AI cannot yet operate. The ultimate goal is building trust, which must be actively engineered through careful product design and go-to-market strategy.

Key takeaways

  1. The Value Shift 2:00

    Because automation has driven the cost of average work to zero, the superpower is no longer using AI, but deciding *what* problem deserves an attack. The scarce skill is choosing which problem to focus on.

  2. The Signal Layer 5:50

    Differentiation requires a 'signal layer'—a deliberate function ensuring the customer's understanding of your product matches your original intent. This involves defining what makes you unique and protecting that message through all channels.

  3. Judgment vs. Taste 11:53

    Broad 'taste' is merely preference under feedback, which AI systems can learn. True differentiation comes from judgment about things that have not happened yet (no data exists) or insights into unobserved customer relationships.

  4. Hamming's Principle 13:54

    A problem is only important when there is a reasonable attack on it. Since AI provides an 'attack on everything,' the critical task is identifying which problem warrants that effort.

  5. Signal Distortion Fixes

    Signal can break in three places: Source distortion (founders compressing context), Organization distortion (signal getting averaged through management layers), and Machine distortion (AI remixing the message into formats like tweets or one-pagers).

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

Agentic Sites: Building Hyper Personalized Websites — Carlos Sanchez, Adobe thumbnail

· 20:43

Agentic Sites: Building Hyper Personalized Websites — Carlos Sanchez, Adobe

The presentation details 'Agentic Sites,' a system for building hyper-personalized websites that adapts content in real time based on user intent and browsing behavior. Instead of generating entire pages, the architecture focuses on customizing specific content blocks (e.g., hero sections, product lists) while grounding all generated content within the site's existing corpus to maintain strict brand guidelines. Key technical advancements include continuous model evaluation across multiple providers for both accuracy and speed, achieving impressive generation latencies as low as 1.1 seconds.

Key takeaways

  1. Hyper-Personalization (Audience of One)

    The goal is to personalize pages in real time based on the user's intent or actions, moving beyond one-size-fits-all web experiences. This drives higher engagement and conversions.

  2. Block-Level Personalization 3:40

    Personalization occurs at the block level (e.g., hero card, product list) rather than generating entire pages, which is crucial for adhering to strict brand guidelines and preventing hallucinations.

  3. Speed is Critical for Conversion 10:58

    The system emphasizes speed, noting that a page generation time of 1.1 seconds was significantly faster than the runner-up's 4.6 seconds, demonstrating that low latency is critical to user experience and conversion rates.

Watch on YouTube Full article

Agents Are Where Microservices Were in 2015 — Roberto Milev & Uday Kanagala, Navan thumbnail

· 19:28

Agents Are Where Microservices Were in 2015 — Roberto Milev & Uday Kanagala, Navan

The talk outlines that AI agents represent a paradigm shift comparable to microservices in 2015, requiring entirely new architectural patterns for reliable production deployment. Key areas of focus include managing agent statefulness (moving beyond stateless APIs), implementing advanced observability via hooks and traces, adopting skills as the primary unit of context, and establishing robust governance through guardrails at the policy layer. The industry is moving toward scoring non-deterministic trajectories rather than asserting fixed outputs.

Key takeaways

  1. Agents are Stateful by Nature 3:54

    Unlike traditional stateless API services, agents require persistent sessions and state management, necessitating specialized agentic runtimes (e.g., AWS Agent Core Runtime) [2:34].

  2. Skills as Context Unit 6:04

    To manage context effectively, the focus should be on treating 'skills'—which include instructions and tool execution logic—as pluggable units of work that allow for progressive disclosure of context [6:04].

  3. Observability via Hooks and Traces 7:16

    Because agents emit excessive thinking output, traditional logging fails. Operational reliability requires intercepting every step (pre-tool/post-tool, pre-decision/post-decision) to capture auto-traces, goals, reasoning, belief status, and confidence scores [7:16].

  4. Testing Non-Deterministic Systems 9:32

    Since agents are non-deterministic, testing must shift from asserting fixed outputs to scoring trajectories—evaluating the efficiency and completeness of the path taken toward a goal [9:32].

  5. Guardrails for Authorization 13:44

    The blurring line between an agent acting on behalf of a user versus using its own service account requires fine-grained authorization policies (guardrails) applied before and after every tool call to prevent sensitive data leakage [13:04].

Watch on YouTube Full article

AI Agents Are Just Distributed Systems Now — Salman Munaf, TikTok thumbnail

· 19:48

AI Agents Are Just Distributed Systems Now — Salman Munaf, TikTok

The core argument is that AI agents, once they interact with external services (tools/APIs), cease being purely model problems and become complex distributed systems challenges. Building reliable agents requires incorporating robust distributed systems thinking—focusing on failure modes, state management, transactionality, and security controls—rather than just improving the LLM itself.

Key takeaways

  1. AI Agents as Probabilistic Coordinators 5:46

    Unlike traditional deterministic workflows that follow a predefined decision tree, AI agents act as probabilistic coordinators. This variability necessitates strong external controls (e.g., circuit breakers, spending ceilings) to ensure determinism and prevent severe consequences.

  2. Handling Failure: Timeout vs. Failure 11:59

    A timeout does not mean failure; it means unknown. To prevent unsafe side effects (like double refunds), agents must utilize request IDs and idempotency keys, allowing for status lookups to confirm if an action already succeeded.

  3. State Management and Context 17:37

    Context that influences an action is state. This state can become stale or conflict with the authoritative source of truth, requiring explicit invalidation and provenance tracking, much like managing a cache.

  4. Security and Control Boundaries

    Agents must operate with scoped credentials (separate read/write permissions) and limited tool access. Furthermore, human approval should be bound to specific actions, actors, and expiry times, not blanket privileges.

Watch on YouTube Full article

From Tokenmaxxing to Trusted Throughput — Mingsheng Hong, Ironclad thumbnail

· 23:04

From Tokenmaxxing to Trusted Throughput — Mingsheng Hong, Ironclad

The talk argues that optimizing AI token usage should not focus solely on cost reduction (austerity). Instead, the goal is to maximize 'Trusted Throughput'—the value derived from code validated by internal engineering and external customers. The speaker emphasizes that as AI makes code generation abundant, the bottleneck shifts downstream to Code Review and Continuous Integration (CI/CD). Key strategies include defining advanced metrics (e.g., weighted merged PRs) and improving developer experience by eliminating flaky tests and measuring wait times.

Key takeaways

  1. AI Usage Dashboards as Smoke Detectors 1:34

    Usage dashboards should track token usage across teams/individuals but must not be positioned as leaderboards or incentives for maximization. Instead, they serve as 'smoke detectors' to identify pockets of low adoption or sudden usage anomalies (1:34).

  2. Focus on Trusted Throughput, Not Cost Reduction 13:11

    The metric for ROI should be 'Trusted Throughput'—high-quality output validated by internal engineering and external customers. Attempting to cut cost before measuring value is premature (8:33).

  3. Metrics Evolution Beyond Lines of Code (LOC) 22:25

    The process for measuring value has evolved from LOC, to open PRs, to merged PRs, and finally to weighted merged PRs that incorporate a complexity score. This moves the focus from volume to quality (11:20).

Watch on YouTube Full article