Topic

Prompt Engineering

All digests tagged Prompt Engineering

AI Engineer Paris 2026 Main Stage: Google DeepMind, ElevenLabs, Hugging Face & Stripe | Day 2 thumbnail

· 8:44:15

AI Engineer Paris 2026 Main Stage: Google DeepMind, ElevenLabs, Hugging Face & Stripe | Day 2

This summary covers advanced topics in production AI systems, focusing on scaling generative media, optimizing LLM inference, and building real-time AI features. Key technical deep dives include customizing generative models (e.g., Flux for action prediction), achieving low-latency speaker diarization, and optimizing model deployment by integrating Hugging Face's `transformers` library into `vLLM`. Furthermore, the talks emphasize that modern AI development requires a global, agent-centric playbook, necessitating localized payments and robust fraud monitoring.

Key takeaways

  1. AI Model Customization is Multi-Layered 23:20

    Customizing models like Flux involves optimizing multiple surfaces: Prompt Upsampling (using VLM/LLM to steer user intent), Moderation (via configurable APIs or embedding into weights using LoRA), and adding new modalities (e.g., Flux Action for robot control).

  2. Optimizing LLM Inference with vLLM 41:40

    The `transformers` modeling backend allows running Hugging Face models directly in `vLLM`, enabling access to advanced features like KV cache, continuous batching, and expert parallelization while maintaining the original model's code base.

  3. Real-Time AI Requires Causal Segmentation 46:40

    Achieving low-latency speaker diarization for voice agents requires moving from batch processing to causal segmentation, which processes audio in streaming chunks to maintain accuracy while minimizing latency (e.g., achieving 400ms latency).

  4. AI Product Playbook Must Be Global and Agent-Ready 50:00

    Successful AI companies must treat their day-one market as the entire world, localizing pricing, payment methods, and adapting their product design to be discoverable and purchasable by AI agents.

Watch on YouTube Full article

GPT 6 + Hyperframe = Crazy combo for expert-level videos thumbnail

· 25:36

GPT 6 + Hyperframe = Crazy combo for expert-level videos

This talk details the advanced workflow for creating high-fidelity, professional launch videos using AI frameworks like Hyperframe and Remotion. The speaker demonstrates how these tools leverage HTML, CSS, and JavaScript to express video timelines, allowing models to generate complex, pixel-perfect animations that go far beyond simple PowerPoint slides. The process is highly iterative, requiring detailed, frame-by-frame feedback to achieve a polished, studio-quality result.

Key takeaways

  1. AI Video Generation Capabilities 2:00

    Modern models, especially with frameworks like Hyperframe and GPT-6 Astra, can replicate complex videos pixel-perfectly, enabling the creation of high-quality product launch content (e.g., achieving 100k+ views on Twitter).

  2. Hyperframe/Remotion Mechanics 5:30

    These frameworks allow the video timeline to be expressed in HTML, enabling models to control animation using JavaScript and bind DOM elements to the video timeline, making the process highly flexible.

  3. Advanced Prompting and Workflow 10:30

    Achieving optimal results requires going beyond simple prompting. The speaker outlines a detailed, iterative process of providing frame-by-frame feedback and refining the story line to ensure visual fidelity and narrative flow.

Watch on YouTube Full article

The Dark Arts of Skill Engineering — Paul Bakaus, Renaissance Geek thumbnail

· 1:04:53

The Dark Arts of Skill Engineering — Paul Bakaus, Renaissance Geek

The talk, 'The Dark Arts of Skill Engineering,' argues that effective AI skill development moves beyond simple prompt engineering and into 'harness engineering.' The speaker details advanced techniques—such as using blind sub-agents, implementing anti-attractors, and utilizing mixture-of-experts architectures—to build robust, deterministic, and highly controllable skills. These techniques focus on exploiting the underlying capabilities of the AI model's execution environment (the 'harness') rather than just the input prompt, resulting in skills that are less susceptible to model drift and more reliable across different deployment environments.

Key takeaways

  1. Harness Engineering vs. Prompting 0:06

    Skills should be treated as extensions of the entire coding/AI harness, not just packaged prompts. This involves leveraging system capabilities like hooks, scripts, and standard output to enforce behavior, which is more reliable than prose instructions. (6:25)

  2. Adversarial Sub-Agents 0:08

    To achieve balanced critique or review, use two or more sub-agents that are blind to each other's output. This prevents a single model thread from anchoring on its own work or failing to detect obvious flaws. (7:55, 10:11)

  3. Anti-Attractors for Divergence 0:17

    To prevent model convergence on common or predictable outputs (the 'median'), implement anti-attractors. Techniques include shaving the next predicted token, generating random seeds (e.g., using celebrities for shaders), or running scripts that introduce unexpected input. (16:59)

  4. Passive Guardrails via Hooks 0:20

    Use hooks (e.g., pre-tool use hooks) to enforce design or code standards (like design linting) by actively preventing the model from writing non-compliant code, rather than relying on post-hoc corrections. (20:38)

  5. Compounding Context and Memory 0:30

    Skills can be made aware of prior sessions by saving intermediate results (e.g., critique files) in a dedicated folder. This allows subsequent runs to build context and track progress over time, enabling multi-session refactoring. (30:00)

Watch on YouTube Full article

Self-Compact Pi Agent: ZERO HYPE Agentic Coding Devlog thumbnail

· 30:03

Self-Compact Pi Agent: ZERO HYPE Agentic Coding Devlog

This devlog introduces the concept of a self-compacting Pi Agent, addressing the critical limitation of context window size in long-running autonomous agent systems. The core innovation is giving the agent the ability to autonomously manage its own context by calling a dedicated tool. By implementing three distinct compaction thresholds (Notice, Warning, and Force), engineers can significantly improve agent reliability, reduce operational costs, and enable scalable, out-of-loop agentic coding workflows.

Key takeaways

  1. Self-Aware Context Management 2:00

    Instead of relying on default compaction settings, the agent is given a dedicated tool to monitor its context window and decide the optimal moment to compact its memory, which is crucial for long-running autonomous swarms (e.g., Fable or Astra swarms).

  2. Three-Tiered Compaction Thresholds 4:10

    The system utilizes three distinct thresholds—Notice, Warning, and Force—to provide the agent with a wide gap for natural stopping points, followed by a short gap before the hard cutoff, maximizing the agent's ability to decide when to compact.

  3. Advanced Prompt Engineering for Control 5:50

    Full control is achieved by overriding the default compaction prompts provided by agent decoding tools (like CodeX or Pi Agent). This includes defining a 'note to self' that survives the summary, enhancing the agent's self-correction capabilities.

  4. Out-of-Loop Scalability 7:30

    The self-compacting mechanism is essential for scaling agents from in-loop to out-of-loop operations, enabling reliable, long-horizon work where human intervention is not present.

Watch on YouTube Full article

Build A Reasoning Model From Scratch 4: Inference Scaling 1 (Temperature, Top-p, Self-Consistency) thumbnail

· 1:37:12

Build A Reasoning Model From Scratch 4: Inference Scaling 1 (Temperature, Top-p, Self-Consistency)

This session details advanced inference-time scaling techniques used to improve Large Language Model (LLM) accuracy without retraining the base model. Techniques covered include Chain-of-Thought (CoT) prompting, Temperature Scaling, Top-p Filtering, and Self-Consistency (majority voting). The core mechanism involves modifying the text generation function to support diverse sampling, demonstrating that while these methods significantly boost accuracy (e.g., achieving 52% accuracy on Math500), they also dramatically increase computational cost and latency.

Key takeaways

  1. Inference Scaling vs. Training Scaling

    Improving model performance can be achieved by increasing compute either during training (e.g., larger models, more data) or during inference (inference-time scaling). Inference scaling techniques include generating more tokens or using advanced sampling methods like majority voting.

  2. Chain-of-Thought (CoT) Prompting 29:03

    Adding prompts like 'Let's think step by step' is a simple, effective modification that significantly boosts the base model's accuracy by forcing intermediate reasoning steps.

  3. Temperature Scaling and Sampling 1:03:40

    Temperature controls the output diversity by rescaling logits before applying softmax. A lower temperature (e.g., 0.5) increases the peak probability, making the model more deterministic, while a higher temperature increases randomness.

  4. Top-p Filtering

    This technique improves quality by filtering out low-probability tokens, keeping only the most likely tokens whose cumulative probability sum up to a threshold $p$ (e.g., 0.8).

  5. Self-Consistency

    Self-consistency uses majority voting: the LLM generates multiple answers (e.g., 3 or 5) using diverse sampling, and the most frequent answer is selected as the final, most robust result. This method is highly effective for numerical tasks like Math500.

Watch on YouTube Full article

How I used AI to build a slop-free web page thumbnail

· 4:58

How I used AI to build a slop-free web page

The speaker details a process for achieving high-quality web design for the Multiplayer AI Manifesto page, emphasizing that while AI was used, the core content and creative direction were human-driven. The process involved writing all copy manually, specifying a desired 'vibe,' and utilizing a 'random-string trick' in prompts to generate design variety. The site was built by launching multiple AI agents (including Fable 5.1) on the Superconductor platform, comparing their screenshots, and then engaging in extensive, iterative, multi-agent chat sessions to refine the final product.

Key takeaways

  1. Content Creation

    All copy was written by hand, and the desired visual 'vibe' was specified in the source document, avoiding AI writing for the text.

  2. Design Variety Trick 2:00

    To achieve design diversity, the speaker used a 'random-string trick' in the prompt, instructing the AI to generate a long alphanumeric string and apply it to the design without mentioning the string itself.

  3. Multi-Agent Testing 2:20

    The process involved sending a Notion link to Superconductor to build the site, requesting a sequence of screenshots using Playwright. The speaker launched 14 different AI implementations (e.g., Fable 5.1, CodeXes, open-source models) to compare results.

  4. Iterative Refinement 3:00

    The final site was refined through a long, multiplayer AI chat session (333 messages), where the speaker and co-founder provided visual feedback (via screenshots) to the chosen agent (Fable 5.1) for continuous improvement.

Watch on YouTube Full article

How to run your first AI UGC campaign (step-by-step guide) thumbnail

· 13:47

How to run your first AI UGC campaign (step-by-step guide)

This guide details an automated, multi-stage workflow for generating hyperrealistic User-Generated Content (UGC) at scale, significantly reducing costs from $20-$50 per video to mere cents per second. The process involves analyzing trending content to identify effective hooks and characters, using advanced AI prompting techniques (like JSON output) to create digital characters with specific 'vibes,' and finally generating the video using specialized APIs (such as Cance 2.5) combined with audio cloning and automated scripting.

Key takeaways

  1. UGC Strategy Foundation

    Effective UGC content requires two parts: a strong hook and a product demo. Scaling involves pairing one product demo with multiple variations (5-10) of hooks to test performance.

  2. Character Generation Techniques 1:48

    To generate a character with a specific 'vibe' while maintaining realism, it is crucial to restrict the model's exploratory space by using JSON-based prompts. This prevents the 'AI slop' look often associated with default model outputs.

  3. Model Comparison for Realism 2:20

    While multiple models (e.g., GPT image 2.5, Gemini 3 Pro) can generate characters, the speaker claims Gemini 3 Pro currently yields the most super-realistic results for character generation.

  4. Automated Video Production Workflow 5:20

    The full workflow uses a tool like 'track' to pull trending data, create a character image, and then use the Cance 2.5 model (via a restricted endpoint) to generate the final video. The process can be automated using a dedicated skill that handles scripting, voice cloning, and captioning.

Watch on YouTube Full article

Tokens Should Have Jobs — Katelyn Lesse & Angela Jiang, Anthropic thumbnail

· 13:21

Tokens Should Have Jobs — Katelyn Lesse & Angela Jiang, Anthropic

The presentation challenges the assumption that all tokens used in agentic systems are fungible. Instead of relying solely on increasing the token budget (brute force), the speakers propose giving tokens specific 'jobs' through advanced strategies. These strategies—Advising, Grading, and Dreaming—allow agents to improve performance and reliability within a fixed budget, particularly when the task requires high precision (e.g., financial analysis). The analysis showed that while increasing the budget improves performance across all methods, specialized strategies significantly reduce the true cost (tokens) required to achieve a perfect, reliable outcome.

Key takeaways

  1. Tokens are not fungible

    The core thesis is that tokens should be assigned specific jobs (e.g., advising, grading, dreaming) rather than being used indiscriminately for simple execution. This allows for more efficient use of computational resources.

  2. Three core agent strategies 3:45

    Strategies include: 1) Advising (splitting an executor from an adviser that provides mid-task guidance); 2) Grading (defining a rubric and using a grader to iterate until a perfect outcome is achieved); and 3) Dreaming (allowing tokens to inspect transcripts and write findings to memory for future runs).

  3. Cost vs. Accuracy in Financial Analysis 11:40

    When evaluating financial tasks (like creating a P&L statement), 80% accuracy is considered useless if 100% accuracy is required. The analysis showed that the baseline 'Execute' strategy required an average of 1.8 million tokens to achieve a perfect answer, while 'Advise' and 'Grade' were significantly more token-efficient.

  4. Optimization depends on the goal

    The choice of strategy depends on the optimization goal: choose 'Advise' for maximum token efficiency, or 'Grade'/'Dream' if maximizing the percentage of perfect, reliable runs is the priority.

Watch on YouTube Full article

Design at the Speed of Adjectives — Paul Bakaus, Renaissance Geek, Inc. thumbnail

· 15:59

Design at the Speed of Adjectives — Paul Bakaus, Renaissance Geek, Inc.

The talk introduces 'Impeccable,' a design skill designed to enhance coding harnesses (like Copilot and Claude Code) by providing a vocabulary to steer AI-generated design. The core thesis is that good design cannot be 'oneshot' or fully automated because it is context-rich, iterative, and requires human decision-making. Instead of automating the process, Impeccable allows users to inject specific adjectives and verbs (e.g., 'bolder,' 'quieter,' 'distill,' 'harden') to guide the AI toward specific design goals, thereby improving the quality of the human-AI collaboration.

Key takeaways

  1. Design is not a one-shot process 9:58

    Good design must be context-rich and iterative. The speaker argues that fully automating design is currently impossible, as human judgment is required to define the emotional territory and audience.

  2. Impeccable facilitates steering, not abdication 13:50

    The tool's purpose is to give users the necessary control to steer the agent using specific design vocabulary. The speaker explicitly rejects the idea of an automatic mode, stating that the point is guiding the process, not letting the AI do all the work.

  3. The traditional design handoff is collapsing 4:16

    The traditional 'waterfall' process (PM $ ightarrow$ Design $ ightarrow$ Engineer) is rapidly breaking down, leading to a blurring of roles where engineers and designers must increasingly work in shared, fluid processes.

Watch on YouTube Full article

The Race to Done: Fable 5.1 vs GPT-6 Astra. Who Wins? thumbnail

· 16:21

The Race to Done: Fable 5.1 vs GPT-6 Astra. Who Wins?

This video compares the capabilities of Claude Fable 5.1 and GPT-6 Astra by having both models build a native Mac clipboard manager from the same initial prompt. The speaker argues that the true measure of a model's utility is not its initial benchmark performance, but its ability to successfully iterate and refine the build through subsequent, detailed prompting. Astra was preferred due to its speed of iteration, lower token usage, and ease of implementing complex functional changes, such as hotkey adjustments and confirmation messages.

Key takeaways

  1. Iteration is the ultimate test of AI utility

    The most critical skill is knowing how to refine and improve a model's initial output (the 'second round of prompting'), rather than relying solely on the initial prompt response.

  2. Model design differences reveal user needs 3:31

    Comparing two models on the same task (e.g., Fable's narrow list view 'Ledge' vs. Astra's wide card view 'Shelf') helps the user discover design preferences they hadn't consciously decided upon.

  3. Speed of iteration impacts quality 10:06

    The speaker found that Astra's ability to process multiple changes (1.0, 1.1, 1.2) in the time it took Fable to complete version 1.0 allowed for more comprehensive refinement and higher quality output.

Watch on YouTube Full article

Workshop: Building and optimizing dictation features thumbnail

· 36:06

Workshop: Building and optimizing dictation features

This workshop details the architecture for building low-latency dictation features using AssemblyAI's APIs. The core strategy involves leveraging the Sync API—a single POST request—to achieve speed superior to traditional async or streaming methods. The process is optimized through three key stages: using key terms prompting for accuracy, implementing connection warming to minimize network overhead (DNS, TCP, TLS), and running a cleanup pass via LLM Gateway (e.g., Qwen3.5 4B Fast) to refine raw transcripts into polished, intent-preserving text. The goal is to deliver results on screen in under one second.

Key takeaways

  1. Sync API Preference 5:35

    The Sync API is preferred for dictation because it avoids the overhead of maintaining a WebSocket connection (streaming) and bypasses the inherent latency floor of traditional async endpoints, which is unsuitable for short, burst dictation sessions.

  2. Latency Optimization via Warming 11:40

    To minimize latency, it is critical to call a warm endpoint (`client.sync.warm`) while the user is recording. This pre-pays the networking costs (DNS, TCP, TLS handshake), ensuring the subsequent transcription request goes straight to inference.

  3. Cleanup Pass with LLM Gateway 18:20

    A cleanup step using an LLM (like Qwen3.5 4B Fast) is necessary to transform raw, spoken text (e.g., 'I think we should meet in 5 minutes') into polished, corrected text while preserving the original intent. This is achieved by prompting the model to act as a function in a pipeline, not an assistant.

  4. Upcoming Dictation API 30:00

    AssemblyAI is rolling out a dedicated Dictation API (`client.dictation.describe`) that will wrap the entire loop (STT + Cleanup) into a single, simplified call, making the process easier for developers.

Watch on YouTube Full article

Accelerate the self-improving AI loop with CoreWeave ARIA thumbnail

· 8:44

Accelerate the self-improving AI loop with CoreWeave ARIA

CoreWeave ARIA is an AI research and iteration agent integrated into Weights & Biases (W&B) designed to accelerate the self-improving AI loop. It addresses common challenges in AI development, such as stalled iteration cycles, massive data volume analysis, and manual dashboard creation. ARIA automates auto-research, analyzes training metrics and agent traces, generates comprehensive reports with suggested next steps, and assists in optimizing LLM prompts and agent performance.

Key takeaways

  1. Automated Auto-Research Loop

    ARIA can conduct auto-research by analyzing recorded training metrics and agent traces to uncover hidden insights. It generates visualization-packed W&B reports and automatically launches follow-up training experiments based on its findings, minimizing manual effort (5:51).

  2. Agent Performance Optimization

    ARIA supports agent development by analyzing production traces and suggesting improvements. It can specifically help refine system prompts and evaluate multiple prompt alternatives using defined datasets to achieve higher quality results at lower latency (7:07).

  3. Comprehensive Workflow Support 2:30

    Beyond research, ARIA handles time-consuming manual tasks like providing advice, generating code, and executing commands, all while supporting concurrent conversations that can continue running in the cloud (2:21).

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

Accelerate agent improvement with LangSmith Engine thumbnail

· 3:25

Accelerate agent improvement with LangSmith Engine

LangSmith Engine automates agent improvement by analyzing large volumes of production traces (e.g., 20,000 traces). It identifies recurring issues—such as agents sending outreach to disqualified prospects without warning—and proactively proposes code changes and updated instructions. Furthermore, it automatically generates evaluation datasets from failing runs, allowing engineers to test proposed fixes against historical failures before deployment.

Key takeaways

  1. Automated Issue Identification

    Engine reviews production traces to surface recurring problems (e.g., agent outreach despite CRM flagging a prospect as disqualified), grouping related issues across multiple agent runs.

  2. Proposed Fixes and Instructions 2:05

    Beyond identifying the error, Engine drafts concrete changes: modifying tools (e.g., adding a 'confirmed disqualified' flag) and refining system prompts to include exceptions (e.g., requiring explicit confirmation before sending).

  3. Automated Evaluation Dataset Creation 2:40

    Engine handles the tedious process of growing evaluation datasets by formatting failing production runs into examples, including reference outputs detailing how the agent should have behaved.

Watch on YouTube Full article

Lada Kesseler: I Trust AI Tests Less Than AI Code thumbnail

· 45:51

Lada Kesseler: I Trust AI Tests Less Than AI Code

Lada Kesseler discusses advanced agentic workflows, arguing that achieving quality with AI agents requires structured 'loop engineering' rather than expecting perfect first attempts. She emphasizes giving agents explicit missions to disagree with and recommends techniques like iterative refinement (the 'centrifuge') and using specialized skills (like TDD) via front matter activation. For build engineers, the core message is shifting from monolithic code generation to modular, verifiable processes that manage complexity through deterministic triggers and layered testing.

Key takeaways

  1. The Centrifuge Principle 11:39

    Quality requires iterative refinement; do not expect AI-generated output to be perfect on the first try. The process involves taking one step, committing it to a file, reading it back, identifying flaws, and repeating the loop until satisfactory (00:13:09).

  2. Agent Ground Rules are for Agents, Not Humans 10:22

    The 'ground rules' or system prompts must give the model a mission to disagree with you (e.g., 'Don't try to please me') rather than just listing best practices. The description field in an agent skill is intended for machine activation, not human readability (00:10:02).

  3. Sketch Prototypes with Markdown 20:43

    For early-stage architecture or complex problem spaces, replace code with a markdown file and an agent. This allows the user to experience the workflow's user experience without committing to production code, serving as a fast, low-fidelity prototype (00:20:43).

  4. Deterministic Verification is Key 27:28

    Use 'verifiers' or deterministic triggers that check for specific standards (e.g., long methods, adherence to style guides) across various files, providing far better results than a single general code review prompt (00:35:29).

Watch on YouTube Full article

How to trace your vibe-coded agent with W&B Weave thumbnail

· 7:22

How to trace your vibe-coded agent with W&B Weave

The video demonstrates how to implement comprehensive observability for AI agents using Weights & Biases (W&B) Weave and the W&B MCP server. By leveraging the `weave for agents SDK`, engineers can add full tracing—including conversations, turns, LLM calls, and tool executions—to an existing agent's logic without modifying its core code. This instrumentation allows developers to monitor performance metrics, track resource usage (tokens, cost), and debug complex interactions, such as identifying model hallucinations.

Key takeaways

  1. Weave provides deep observability for AI agents

    The tracing structure follows a clear hierarchy: Agent $\to$ Conversation $\to$ Turn $\to$ LLM Call + Tool Call. This detailed view is crucial for understanding agent behavior and performance.

  2. Non-invasive instrumentation using W&B MCP

    Observability can be added by prompting a coding assistant (like Claude Code) to inject the necessary tracing logic via the `weave for agents SDK`, avoiding changes to existing application code.

  3. Debugging and Evaluation Capabilities

    The Weave UI allows engineers to inspect individual conversations and turns, providing step-by-step visibility into tool usage (e.g., Tavali search) and LLM decisions. This is critical for debugging hallucinations or unexpected agent behavior.

Watch on YouTube Full article

Agent Frameworks Considered Harmful — Rémi Louf, .txt thumbnail

· 20:29

Agent Frameworks Considered Harmful — Rémi Louf, .txt

The talk details the creation of a robust, event-driven agent runtime system designed to overcome limitations in existing AI frameworks and chat interfaces. The core innovation is moving from string-based prompts and complex graphs to an auditable, content-addressed store where every component (system message, skill description, user question) is hashed and stored separately. This architecture ensures full traceability, allowing for precise diffing between runs and reliable replaying of requests against different models, making the system highly debuggable and scalable.

Key takeaways

  1. Event-Driven Architecture (EDA) 15:37

    The system relies on agents subscribing to typed events rather than maintaining complex graphs with edges. This simplifies orchestration significantly, allowing for 'funneling' and 'fan out' without requiring code knowledge; users only need to know what events exist in the system.

  2. Content-Addressed Prompt Store 20:11

    Prompts are no longer rendered strings. Instead, every part (system message, skill description, tool definition, user question) is hashed and stored as an identifier. A prompt is represented as a list of these hashes, enabling precise auditing.

  3. Enhanced Observability

    The system implements two key boundaries: typed tool calls and typed events. This rigorous typing prevents malformed or non-existent inputs from breaking the pipeline, which was necessary because early failures included rejected/malformed events.

Watch on YouTube Full article

The Missing Layer: Design Taste in AI Agents — Hassan El Mghari, Together AI thumbnail

· 14:10

The Missing Layer: Design Taste in AI Agents — Hassan El Mghari, Together AI

The talk addresses the critical role of design and User Experience (UX) in making AI applications successful, arguing that polished aesthetics are a major competitive advantage. The speaker details methods to avoid generic 'AI slop' by codifying anti-patterns using tools like Hallmark, leveraging specific themes, and adopting structured development practices such as providing visual references, writing detailed prompts, and iterating with smaller open-source models.

Key takeaways

  1. Use Visual References (Inspiration Vault)

    Always provide AI models with a large collection of screenshots or inspiration images to guide the design output. This significantly improves the final product quality.

  2. Structure Prompts and Features

    Instead of sending one massive prompt for all features, break down development into smaller steps (one or two features per prompt) and use longer, more specific prompts (e.g., voice notes) to guide the agent.

  3. Iterate with Smaller Models 10:53

    Start base builds using larger models (like Codex/Claude Code), but use smaller, faster open-source models (such as GLM 5.2) for iterative refinement and polishing to achieve better results.

Watch on YouTube Full article

Trading Desks to Clinical Trials: Parallels in Applied Vertical AI — Ayush Bhardwaj, Allos AI thumbnail

· 20:02

Trading Desks to Clinical Trials: Parallels in Applied Vertical AI — Ayush Bhardwaj, Allos AI

The talk outlines a structured methodology for building and iterating in applied vertical AI, arguing that model infrastructure and APIs are commodities. The true 'moat' lies not in the technology itself, but in proprietary data and deep domain expertise. The process requires narrowing the problem scope, curating unique datasets (like failed experiments or trade theses), and crucially, integrating a human domain expert ('the user') to create an endless learning loop that guides prompt refinement and error analysis.

Key takeaways

  1. The Moat is Domain Expertise 12:30

    In vertical AI, the competitive advantage does not come from the model (e.g., Claude or ChatGPT) or the infrastructure; it comes from proprietary data and domain expertise which must be curated by human experts.

  2. Focus on Narrow Tasks 6:35

    When formulating a problem for an AI agent, do not try to solve everything at once. Break down complex tasks into very narrow, specific steps (e.g., ranking stocks based on IT capital expenditure in US equities).

  3. The Importance of Proprietary Data 8:00

    Generic data sources are insufficient. The most valuable assets are proprietary datasets that are expensive to acquire or withheld by industry players (e.g., failed clinical trials, internal trade theses).

  4. Hire the User, Not Just the Model 15:30

    The single most critical step is hiring a domain expert ('the user'). This person guides the tool by curating sources, refining prompts, and performing judgment—a process that transforms generic AI tools into industry-specific assets.

Watch on YouTube Full article

Shipping AI to a Million Patients Without an A/B Test — Jared Joselowitz, Ufonia thumbnail

· 19:15

Shipping AI to a Million Patients Without an A/B Test — Jared Joselowitz, Ufonia

The talk details how Ufonia built a comprehensive safety and evaluation stack for Dora, a conversational AI used in clinical post-op follow-ups. Because randomized A/B testing is unethical and illegal when dealing with patients, the system cannot rely on reactive rollbacks or standard model benchmarks. Instead, the approach shifts to rigorous simulation (the 'inner loop') using frameworks like Matrix, which employs simulated patients (PatBot) and an expert LLM judge (BevJudge). Safety is proven by optimizing prompts against a cost matrix (e.g., prioritizing sensitivity over overall accuracy) and utilizing automated prompt optimizers like Jeppa, ensuring the system ships evidence, not just a model.

Key takeaways

  1. Safety Constraints in Healthcare AI 3:50

    Standard software safety nets (A/B testing, rollbacks) fail when dealing with patients because randomizing into a worse variant is unethical and illegal; once a call is made, it cannot be undone. The model card's benchmark scores are insufficient defense at post-incident reviews.

  2. The Necessity of Simulation 10:50

    Since real-world testing (the 'outer loop') is too risky, the process must emulate high-reliability industries like self-driving cars. The simulation framework, Matrix, uses an LLM (PatBot) to play the patient against hazards written by clinicians.

  3. Automated Hazard Detection 13:50

    A second LLM, BevJudge, validates simulated dialogues. It is trained and validated against a corpus of 240 examples labeled by 10 clinicians from 10 specialties, achieving expert-level performance (e.g., F1 score of 0.96) with near-perfect sensitivity.

  4. Optimizing Prompts via Cost Matrix 17:00

    Instead of manual prompt engineering, the process uses optimizers like Jeppa (Genetic Pareto), which iteratively updates prompts based on a defined cost matrix. This allows optimization for specific metrics, such as maximizing sensitivity (catching red flags) over general accuracy.

Watch on YouTube Full article