Notion

From coding to Knowledge work agents — Karan Vaidya, Composio

Sep 3, 2026 · 20:42

Karan Vaidya, cofounder and CTO of Composio, argues coding agents raced ahead not because models are better at code but because code already had six primitives knowledge work lacks: centralization, history, context, verification, governance, and reversibility. He walks each one, from the repo as a single source of truth versus a deal scattered across Salesforce, Notion, Gmail, Slack, and Zendesk, to git history against agents that start blank every time. He recounts pointing his own OpenClaw at hiring outreach that mass-emailed candidates and ended up on Twitter, noting every technical check passed while nothing tested whether the outreach should have gone at all. He cites a Meta alignment director whose email agent kept deleting messages until 200 were gone, showing prompts get compacted away and walls must live outside the agent. He concedes reversibility is hardest, since sent emails and wires cannot be recalled, so Composio uses sandboxes to catch mistakes before they reach the real world.

How to Generate Mergeable Code with a Context Engine — Peter Werry, Unblocked

Aug 27, 2026 · 18:36

Peter Werry of Unblocked argues that access to information does not equal understanding—organizational context is the bottleneck for AI agents. He likens agents to expert engineers resetting knowledge every task, falling prey to radiology's 'satisfaction of search'; million-token windows distract. Werry demos the context engine generating an architecture diagram, then runs the same optimization plan in Claude Code twice: with it, under a dollar and about a minute; without, roughly double the time and more cost, because later steps loop on wrong assumptions. He also shows a review agent boosting comments by seniority, a drop in flagged issues traced to a Slack thread, and open-source tools: a GitHub-history query engine and a social graph showing thin review coverage.

Unlock Agent Autonomy: The Runtime for AI-Native Systems — Tushar Jain, Docker

Aug 20, 2026 · 22:50

Tushar Jain of Docker argues safety, not intelligence, is the blocker to agent autonomy, proposing a runtime beneath every model and harness. His evidence: a nightly agent that posted a private report as a PR, and an incident agent that widens access from logs to Slack to GitHub. The runtime has three pillars: containment with controls outside the agent's boundary, just-in-time tools scoped per task, and intent-based access that refuses off-task asks like email. Docker's new SPX tool runs agents in micro-VMs with injected stub credentials and scoped sandboxes locally, in the cloud, or in a VPC. Demos split a PR-review and Notion-writing job across two sandboxes, fan out to six parallel sandboxes, and show an early prototype auto-creating a scoped sub-sandbox for GitHub.

Prototyping as Leadership: How a CTO Ships with AI Agents — Hursh Agrawal, The Browser Company

Aug 20, 2026 · 18:18

Hursh Agrawal, CTO and co-founder of The Browser Company, argues AI coding agents let leaders keep building: despite 15+ meetings, 7 direct reports, and a toddler, he ships 2–10 PRs/week. He says frontier models turn over every three months, so hands-on building is the only way to judge them and show engineers working prototypes. His method is an overnight loop: a coworker agent gathers Slack/Jira/Notion context into a prompt at 5pm, coding agent runs for hours, and a morning hour reviews tests, CI, and AI code review. He details three overnight uses: building features, hill-climbing evals from feedback JSONs, and training custom models like a PII classifier on AWS. He warns leaders to avoid critical path work and to rely on trustworthy CI, feature flags, a prototype branch, and readable PRs.

Multiplayer agentic engineering — Arjun Singh, Superconductor

Aug 9, 2026 · 18:44

Arjun Singh explains how Superconductor enables multiplayer agentic engineering by making agents model-agnostic, cloud-isolated, and reachable from Slack, desktop, and GitHub as one shared session. He argues agents should run in a configurable network sandbox for least privilege, letting non-technical staff trigger real work without dev setups; a meeting bot left in a Google Meet at their expo booth picked up a passerby's idea, opened a ticket, and added acceptance-criteria fields. He advises benchmarking agents on your own codebase because SWE-bench is Python while they are Ruby on Rails, citing one month: 10.5 billion tokens, 3,300 Claude Code runs worth about $10,000, and Codex running four times as many sessions for less money. Takeaways: sandbox your code, integrate agents into human interfaces, stay model-agnostic.

fighting slop with slop — Vaibhav Gupta, Boundary

Jul 31, 2026 · 21:32

Vaibhav Gupta of Boundary argues that AI slop can be fought with slop: instead of code reviews, his team relies on agents that read other agents' transcripts and on hard invariants like architecture.md files and CLI checks. He explains how they ship a stable programming language, BAML, without reading all code, using agents that flag hallucinations, tool-call errors, and inefficiencies from Claude transcripts, then A/B test language features by token spend and error rates. He attacks TypeScript as baking slop in—string coercion on sort, unsafe any—and designs BAML with inferred error types that prove division-by-zero is handled or the build fails. BAML works across Python, TypeScript, Rust, and more, with type-safe functions, lambdas, and generics across boundaries, plus zero-cost execution traces and generated CLI tools. His closing challenge: build these sloppy tools yourself, constrain the systems underneath, and rethink foundational layers like Git, databases, and programming languages.

How Forward Deployed Engineering is done at Ramp — Leo Mehr

Jul 28, 2026 · 14:05

Leo Mehr, Director of Engineering at Ramp, lays out two principles for Forward Deployed Engineering: always be scoping and scale with tokens. He illustrates scoping with a Friday night SAP S4 HANA integration request that required pausing to validate urgency, and a painful lesson where his team built an Android reimbursement feature only to learn the customer mandated iOS devices. For scaling with tokens, Ramp automated the request intake stage with a Notion agent that saved about 20% of scoping time by asking iterative questions and generating specs. Mehr warns that without proper scoping, agents become a 'token maxing slop cannon,' while without agent automation, competitors will overtake you. He concludes that the future of FDE requires both human judgment for scoping and agents for volume.

Full Workshop: Setting Yourself Up for Success —Jason Liu, OpenAI Codex

Jul 24, 2026 · 1:15:02

Jason Liu walks through how to set up OpenAI's Codex for maximum productivity, using voice dictation, app shots, computer use, and a personal memory vault to delegate and automate almost every task. He demonstrates creating skills and plugins from past work, using compaction to keep threads running for weeks with hundreds of sub-agents, and setting up automations with heartbeats and goals. Specific examples include auto-checking flights, editing iMovies via computer use, and having a chief-of-staff thread that monitors Slack and updates task lists. He also covers security permissions (auto-review vs full auto), tips for new users to start with low thinking mode to save tokens, and how to build skills that self-improve by editing their own files. The workshop emphasizes that threads can now communicate with each other, enabling manager-like orchestration and long-running work streams.

The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents

Jul 17, 2026 · 1:00:16

In the 'Great Loops Debate' hosted by Ali Howe, Geoff Huntley, Ian Livingstone, Dex Horthy, and Greg Pstrucha argue whether there is a delta between the hype behind loops in AI-assisted development and what works in practice. Team No Delta (Ian, Geoff) contends loops are inevitable and already cost-effective at $10.42/hour, with models surpassing average coders. Team Delta (Dex, Greg) counters that hype outruns discipline: loops work only for deterministic tasks, quality remains low, and token spend scales unsustainably. The debate covers loop history, anatomy (verification, context windows), and the feasibility of fully autonomous software factories, concluding that while loops boost productivity 2-3x, the vision of lights-off factories is premature.

Recursive Model Improvement — Lee Robinson, Cursor, SpaceXAI

Jul 15, 2026 · 20:32

Lee Robinson, head of ML at Cursor, explains how recursive model improvement accelerates AI training through inner and outer loops. The outer loop gathers user feedback and online metrics to refine evals, while the inner loop uses high-quality evals and difficult problems to climb performance. Composer 2.5, released in May, became Cursor's most popular model by balancing speed, intelligence, and cost. To scale, Cursor partners with SpaceX for compute via Colossus (122 days to build 100k GPUs) and develops textual feedback where a teacher model hints at improvements during RL rollouts. Robinson details reward hacking on public benchmarks and the creation of CursorBench, a private eval set. He envisions agent-based automation where researchers launch experiments from Slack and models train derivative models, creating a self-improving intelligence loop.

Research to Reality: Bringing Frontier ML Research to Production - Vaidas Razgaitis, Higharc

Jun 28, 2026 · 14:57

Vaidas Razgaitis, Senior Research Engineer at Higharc, presents three tactical focus areas to accelerate the handoff of frontier ML research into production features. First, he advocates for a Research Prototype Taxonomy Document—a technical design document tailored for ML that maps domain context, business goals, type safety, persistence, and system architecture. Second, he details Higharc's monorepo of cleanly isolated microservices with a layered API/business logic/data structure, enabling researchers to own individual services. Third, he explains using Graphite for stack diffs to decompose monolithic prototypes into small, reviewable PRs that tap subject matter experts asynchronously. The talk offers diagnostic questions to assess team velocity across these three levers.

Why Can't Anyone Answer Questions About the Business? — Garrett Galow, WorkOS

Jun 11, 2026 · 19:06

Garrett Galow from WorkOS built Studio, an internal workspace where anyone can ask natural language questions against Snowflake, Linear, and Notion, and get reusable widgets instead of filing a request. The LLM generates declarative JavaScript widgets that call data sources directly, making subsequent runs deterministic and cheap. Three techniques made it reliable: preflight sequencing injects schema context only when a tool is invoked, a layering rule tells the model to distrust its own knowledge about WorkOS and use primary sources, and query validation catches valid SQL that returns zero rows before hardcoding it into a widget.

Self Driving Products: Product Signals to Pull Requests — Joshua Snyder, PostHog

Jun 10, 2026 · 15:39

Joshua Snyder of PostHog explains how they're building a pipeline that turns product signals—errors, Slack messages, session replays—into automated pull requests. He reveals that off-the-shelf embedding models cluster signals by structural similarity, so they embed LLM-generated queries instead. He argues specificity determines whether the agent produces a useful PR, with error tracking being immediately actionable while Slack and replay usually are not. He advises starting with costly agents to discover patterns, then collapsing expensive steps into one-shot calls.

Why your agents need decision traces, not just documents — Zach Blumenfeld, Neo4j

May 29, 2026 · 20:12

Zach Blumenfeld from Neo4j argues that context graphs—a graph-based layer storing decision traces, precedence, and causal chains—extend standard RAG to make AI agents more accurate and explainable. A financial analyst agent, for example, can reject or accept a request by retrieving past decision traces and structurally similar precedents via graph embeddings, not just semantic similarity. Neo4j's one-command tool `uvx create-context-graph` scaffolds a full-stack app with backend, frontend, demo data, and MCP server, supporting 22 built-in domains or custom ontology generation. The underlying `neo4j-agent-memory` package handles entity extraction through a spaCy-to-GLiNER-to-LLM pipeline with deduplication and integrates with pydantic AI, LangGraph, Crew, Google ADK, and others. The episode also covers data connectors for GitHub, Notion, Jira, and Slack, and the ability to store and query decision traces with timestamps, though automated trace quality evaluation is still evolving.

Mergeable by default: Building the context engine to save time and tokens — Peter Werry, Unblocked

May 3, 2026 · 1:41:25

Peter Werry of Unblocked argues that context engines—systems that supply AI agents with only the relevant organizational context—are critical to avoid agent doom loops and wasted tokens. He debunks three myths: naive RAG, connecting MCP servers, and bigger context windows do not solve the context problem. Werry describes building a social engineering graph to identify experts and distill team best practices, and shares hard lessons including hiding conflicts and caching answers. In a benchmark task, Unblocked's context engine reduced a 2.5-hour, 21-million-token task to 25 minutes and 10 million tokens. The talk offers a practitioner's guide to building context engines with conflict resolution, personalization, and access control.

Human-in-the-Loop Automation with n8n — Liam McGarrigle

May 2, 2026 · 1:19:22

Liam McGarrigle of n8n shows how to build a secure human-in-the-loop automation agent using n8n's visual workflow system, with a Gmail and Google Calendar management agent as the concrete example. He walks through wiring a chat trigger, an AI agent with simple memory, and tools that the agent can call, such as sending emails and creating calendar events. The key addition is a human review node placed between the agent and destructive tools, which intercepts actions and presents them for approval via chat—preventing accidental sends or event creation. McGarrigle emphasizes naming nodes and writing tool descriptions to guide the LLM correctly, and demonstrates using expressions to format readable approval messages. He also covers extending the agent to Slack, adding scheduled runs for autonomous hourly inbox checks, and using sub-agents for specialized tasks. Additional topics include n8n's native MCP server for integration with Claude Code, enterprise Git-based environments for workflow management, and building custom REST APIs within n8n. The session focuses on giving developers observability and control over AI workflows, ensuring agents are not black boxes.

Agents for Everything Else — swyx

May 1, 2026 · 14:10

swyx, co-founder of AI Engineer Conferences, details how his team of nine full‑time people uses coding agents like Devin and Town to run the conference, moving from a non‑AI stack to agents that handle everything from Figma‑to‑website conversion and schedule management to buying a lobster for the event. He claims these agents save “yak shaving” and increase human productivity because employees enjoy faster feedback cycles, leading to more work like animations and polish. The team now manages a 1,000‑person conference with plans to handle 6,000 in San Francisco without growing headcount. Swyx also advocates for “agents for everything else,” predicting that the primary user of software will shift from humans to bots, making APIs and MCPs more important than dashboards. He urges attendees to adopt agents and “prescribe” them to skeptical coworkers.

Building your own software factory — Eric Zakariasson, Cursor

Apr 28, 2026 · 1:23:37

Eric Zakariasson, an engineer at Cursor, explains how to build a 'software factory' by scaling from one agent to many, shifting from worker to manager. He outlines six stages of autonomy, from spicy autocomplete to the dark factory, and emphasizes that most teams are stuck at levels two or three. Key primitives include modular codebases, guardrails like rules and hooks that emerge dynamically, enablers such as skills and MCPs, and verifiable systems like automated tests. Cloud agents with isolated VMs allow agents to run asynchronously, test their own work via computer control, and scale to thousands. Eric shares internal automations like daily reviews, PR comment analysis, and continual learning that extracts rules from chat transcripts. He concludes with strategic advice: front-load context, don't outsource critical decisions, and build tools and systems to capture flywheels, noting that human accountability remains essential.

One Login to Rule Them All: Cross-App Access for MCP — Garrett Galow, WorkOS

Apr 28, 2026 · 23:24

Garrett Galow from WorkOS introduces Cross-App Access (XAA) for MCP, solving the problem of repeated OAuth consent screens when connecting agents to multiple services. The flow leverages a three-way trust between the MCP client, server, and an Identity Provider like Okta: a single SSO login issues an IDJag token that is exchanged for short-lived access tokens across all MCP servers without manual intervention. A demo shows Figma automatically connecting after an Okta login. The approach improves security—if the IdP session is revoked, tokens cannot refresh—and requires minimal IT setup: granting permission for the client to request server access. Currently only Okta supports XAA; Azure/Entra does not yet. The session also notes that authorization scopes are not handled by default but are a future consideration.

The End of Apps — Kitze, Sizzy.co

Apr 23, 2026 · 20:18

Kitze, creator of Benji and founder of Tinker Club, argues that current productivity apps and AI agents are unreliable and too complex for most users, predicting a future where AI prompts humans instead of the reverse. He traces his 24-year obsession with productivity tools—from a childhood to-do list to building Benji with 60 features—and his move to self-hosting after the ChatGPT moment. Kitze critiques custom agents like OpenClaw as too tinkerer-focused, cloud agents like ChatGPT as too nerfed, and believes local models on devices (Apple, Google Pixel) will win for normies, enabling AI to automatically manage notifications, emails, and tasks. He shares his own experiment, Wolfer, designed for predictable multi-agent orchestration without memory systems, using nested topics for context. The episode delivers a strong claim: the role of AI will invert, with machines prompting humans for decisions while handling all background work.

The Future of MCP — David Soria Parra, Anthropic

Apr 19, 2026 · 18:46

David Soria Parra from Anthropic argues that MCP (Model Context Protocol) is the key to connecting agents to tools and data in production, with 110 million monthly downloads—outpacing React's growth at the same stage. He lays out a 2026 connectivity stack combining Skills, MCP, and CLI/Computer Use, each suited for different needs, and emphasizes that best agents will use all three seamlessly. To improve client harnesses, he introduces Progressive Discovery—deferring tool loading via Tool Search to reduce context usage—and Programmatic Tool Calling, where models write scripts to compose tool outputs efficiently. Upcoming MCP protocol improvements include stateless transport (with Google) for easier scaling, async agent-to-agent tasks, enterprise features like Cross App Access and Server Discovery via well-known URLs, and a Skills-over-MCP extension for shipping usage instructions with servers. He calls for community feedback on these directions.

Cognitive Exhaust Fumes, or: Read-Only AI Is Underrated — Šimon Podhajský, Head of AI, Waypoint

Apr 8, 2026 · 11:31

Šimon Podhajský argues that read-only AI systems that analyze personal digital exhaust without the ability to write back are more valuable than agentic AI that acts on users' behalf. He built a system ingesting six read-only sources (email, journal, tasks, CRM, browser sessions, notes) that surfaces insights like intention-action gaps, attention drift, and relationship decay via cross-source pattern detection—things no single source reveals. For example, a weekly reflection skill in Claude synthesizes a brutal review of his week, and a cross-source query maps his recent reading to contacts in his CRM using Vivaldi SQLite and Clay MCP. He emphasizes risk asymmetry: read-only errors cost nothing, while write errors can be unbounded. He also acknowledges security risks like the mosaic effect and Simon Willison's lethal trifecta, noting that shell access still allows exfiltration, but argues that examined risk is better than ignorance.

Building Intelligent Research Agents with Manus - Ivan Leo, Manus AI (now Meta Superintelligence)

Dec 30, 2025 · 1:21:30

Ivan Leo of Manus AI introduces the Manus API and Manus 1.5, positioning the platform as a general action engine for building intelligent research agents. He demonstrates how the API enables asynchronous task dispatching, file uploads with automatic 48-hour deletion, and webhooks for scalable workflows. The workshop covers creating a Slack bot that integrates Manus's browser operator, file attachments, and connectors to private data sources like Notion. Leo shows real-time demos including a custom French learning app, a conference event scraper with calendar integration, and an invoice processing bot that references company policies. He also discusses the roadmap for memory persistence, document exporting (PPTX/PDF), and enhanced permission systems for browser automation.

Ship Production Software in Minutes, Not Months — Eno Reyes, Factory

Jul 25, 2025 · 16:06

Eno Reyes, cofounder and CTO of Factory, argues that AI agents can orchestrate the entire software development lifecycle, moving beyond vibe coding to agent-native development where enterprises delegate planning, coding, testing, and incident response to autonomous droids. He explains that AI tools are only as good as the context they receive—missing context from meetings, whiteboards, or Slack is the primary cause of failure, not LLM quality. Factory's droids search codebases, leverage organizational memory, and question unclear tasks before executing, from generating PRDs and tickets to creating runbooks and RCAs from sentry alerts. Reyes demonstrates how an agent can convert user transcripts and ad-hoc notes into a full feature plan, then break it into parallel tickets for multiple code droids. For incident response, droids pull logs, historical runbooks, and team discussions to produce mitigation plans in minutes, cutting response times in half and shifting from reactive to predictive operations. He emphasizes that the future belongs to engineers who manage agents—thinking clearly and communicating effectively—rather than those writing every line of code.

Windsurf everywhere, doing everything, all at once - Kevin Hou, Windsurf

Jun 23, 2025 · 16:03

Windsurf head of product Kevin Hou explains the company's philosophy of a shared human-AI timeline and its vision to be everywhere, do everything, and work all the time. The AI ingests context from tools like Google Docs, Figma, GitHub, and Notion, and takes actions beyond coding—opening PRs, deploying, and reviewing code. Windsurf generates 90 million lines of code daily and processes over 1,000 messages per minute. Its new model SWE-1, trained on software engineering workflows, achieves near-frontier performance with a fraction of the resources. Hou emphasizes a data flywheel where user feedback on real workflows drives continuous improvement, arguing that successful AI products in 2025 require harmony among model, data, and application.

Just do it. (let your tools think for themselves) - Robert Chandler

Jun 10, 2025 · 6:50

Robert Chandler, co-founder and CTO of WordWare, argues that current low-level MCP tools wrapping APIs directly cause agents to be slow, expensive, and unreliable, citing an example where a Slack MCP took five minutes and failed to send a message. He advocates for agentic MCPs that blur the line between tool and agent, giving tools more agency and simple natural language APIs. Chandler demonstrates WordWare's new MCP toolbox, which turns workflows like a competitor analysis (scraping Twitter, writing to Notion) into a single, reusable tool for agents like Claude. This approach yields highly reliable, repeatable, and aligned results, offloading complex tasks from the main agent and allowing it to focus on reasoning. The episode promotes building tools that think for themselves, following the pattern of specialist teams like the Avengers.

Beyond Conversation: Why Documents Transform Natural Language into Code - Filip Kozera

Jun 10, 2025 · 10:57

Filip Kozera argues that chat-based interfaces like ChatGPT create ephemeral, polluted context windows and lack forced clarity, making them poor for specifying complex systems, while documents naturally force rigor and structured thinking. He advocates shifting from conversational brainstorming to document-driven workflows, where humans precisely articulate intent for AI agents. Kozera introduces background agents that run asynchronously, triggered by events like emails or meetings, and surface only when needing human approval, turning the human role into one of 'swiping left or right' to approve or edit outputs. He envisions a future where humans manage swarms of such agents, first adopted by prosumers and later by enterprises, with taste and intent becoming critical for imbuing personal brand into agent outputs. The episode presents a clear progression from chat-based brainstorming to structured document-driven agent systems.

The Knowledge Graph Mullet: Trimming GraphRAG Complexity - William Lyon

Jun 3, 2025 · 32:52

William Lyon presents the 'Knowledge Graph Mullet' concept, combining property graph interfaces with RDF triple storage in Dgraph to optimize GraphRAG systems and AI agent development. Dgraph uses a property graph model for data modeling and DQL (inspired by GraphQL) for queries, while leveraging RDF triples for scalable storage and data interchange. Features include vector similarity search (e.g., finding articles about 'money laundering'), geospatial indexes, and a Model Context Protocol (MCP) server that exposes tools to models like Claude Desktop for auto-generating schema and querying. Lyon demonstrates building a news knowledge graph from the New York Times, chunking articles into nodes, and using graph traversal to surface related topics after vector search. He also showcases Hypermode agents, created from a prompt with access to GitHub and Notion via MCP servers, which can analyze repos like hyper-news and generate social media posts with code snippets, then save them to a Notion workspace. Hypermode agents are now in early access.

Self Coding Agents — Colin Flaherty, Augment Code

Apr 21, 2025 · 17:23

Colin Flaherty, founding researcher at Augment Code, describes how the company built an AI coding agent that wrote over 90% of its own 20,000-line codebase with human supervision. The agent autonomously added third-party integrations like Google Search and Linear by searching its own codebase and even used its own Google Search tool to look up Linear API docs. It profiled and optimized itself, replacing synchronous file hashing with a process pool after adding print statements and running sub-copies. Flaherty argues that agent capabilities improve with better context engines, code execution environments, and test harnesses—adding test-driven iteration boosted a bug-fixing benchmark by 20% versus 4% from just upgrading the foundation model. He cautions that agents are general-purpose, not category-specific, and have different strengths than humans, making knowledge bases crucial for onboarding. With code becoming cheap, the focus shifts to product insights and design, while better tests enable greater autonomy and accelerate agent self-improvement.

The Hidden Costs of Building Your Own RAG Stack — Ofer Vectara

Feb 22, 2025 · 15:14

Ofer from Vectara argues that building your own RAG stack comes with seven hidden costs: irrelevant responses and hallucinations, high latency, scaling and cost issues, security and compliance challenges, vendor chaos from multiple components, unsustainable expertise requirements, and limited non-English language support. He details how each pitfall compounds at enterprise scale, citing the need for hybrid search, reranking, and continuous evaluation to maintain quality. Vectara offers a turnkey RAG-as-a-service platform that handles parsing, chunking, embedding, vector search, retrieval, and hallucination detection. Ofer highlights Vectara’s open-source HHEM model for hallucination evaluation, downloaded over 3 million times, and a leaderboard showing some LLMs hallucinate at rates above 10%. The platform supports deployment in SaaS, VPC, or on-premises, with built-in access control and explainability.

The era of unbounded products: Designing for Multimodal IO: Ben Hylak

Sep 25, 2024 · 20:32

Ben Hylak, founder of Dawn and former Apple Vision Pro designer, argues that the key to building intuitive AI products in the era of unbounded interfaces is adding structure—highlighting what matters, establishing hierarchy, and leveraging familiarity—lessons from designing VisionOS. He shows how successful AI apps like Dot, Perplexity, and Claude use structure (e.g., Claude pulling code into artifacts) while the Vercel chatbot's inline dynamic UI is an anti-pattern because it disrupts conversation flow. For agents, spreadsheets (like Clay) make unfamiliar multi-step tasks familiar. Looking ahead, Hylak predicts less prompt engineering via sparse autoencoders for millions of ranked, personalized presets, shifting product evaluation from evals to user analytics as apps become increasingly personalized.