Channel

AI Engineer

Digests from AI Engineer

Inside 847 Production Clinical AI Notes — Sebastian Fox, Composo thumbnail

· 19:48

Inside 847 Production Clinical AI Notes — Sebastian Fox, Composo

This talk addresses the critical challenge of evaluating high-stakes AI systems, particularly ambient scribes in healthcare, where dangerous failures often manifest as subtle omissions or hallucinations rather than obvious errors. The speaker argues that traditional verification methods (like fixed rubrics or simple difference checks) fail because the 'standard of good' is tacit, contextual, and constantly evolving. A proposed solution involves building a continuous evaluation loop: Discovering failure modes from real-world outputs, capturing expert judgment on these modes, and calibrating every new output against this accumulated, case-specific context rather than a static rule set.

Key takeaways

  1. High-Stakes Failure Modes 2:09

    In clinical notes, the most dangerous failures are often subtle omissions (e.g., missing jaw pain symptoms) or hallucinations that look technically correct but are factually wrong. In large studies, nearly 1 in 20 notes carried an error serious enough to cause significant harm [1:29].

  2. Limitations of Current AI Evaluation 11:43

    Verification is only easy for the 'easy half' (e.g., spotting differences between transcript and note). The hard part is determining which difference—an omission, change, or addition—actually matters in context [7:03]. This judgment is tacit, contextual, and moving.

  3. The Continuous Evaluation Loop

    To overcome the limitations of static rubrics, the recommended approach is a continuous loop: 1) Discover failure modes from real outputs (building a 'failure mode ontology'), 2) Capture expert judgment on these modes, and 3) Calibrate every output against this accumulated, case-specific context, rather than relying on fixed weights or prompts [13:49].

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

Coding Agents Don't Scale Themselves. Neither Do Your Teams. — Patrick Debois, Tessl thumbnail

· 22:06

Coding Agents Don't Scale Themselves. Neither Do Your Teams. — Patrick Debois, Tessl

The shift toward autonomous systems (the 'dark factory') is not limited by technology but by organizational readiness. The core message is that the focus must move from fixing code produced by AI agents to improving the underlying system and processes. Scaling requires moving beyond solo developer efforts to establishing centralized, reusable platforms and mandates for context authoring and tooling.

Key takeaways

  1. Organizational Readiness vs. Technology Limits

    The resistance to advanced automation (like continuous delivery or the dark factory) is not due to technological impossibility but because organizations are not yet structured for it. The differentiator will be the team, platform, and organization, not the technology itself.

  2. Shift Focus from Code Fixing to System Improvement 8:40

    Developers should stop focusing on fixing the code produced by agents. Instead, they must improve the system architecture and processes (e.g., improving test coverage or documentation generation) that guide the agent.

  3. Scaling Requires Platform Ownership 21:10

    To scale automation beyond individual teams, organizations must establish centralized 'paved roads' and dedicated owners for reusable components (e.g., authentication systems, linters, or context registries). This prevents technical sprawl.

  4. Key Metrics for Measuring Progress 15:38

    Productivity should be measured by two metrics: the reduction in 'human touches' required to get a correct result, and the degree of fix/improvement that is shared across multiple users (the multiplier effect).

Watch on YouTube Full article

Preferences Over Benchmarks: Model Routing — Archana Kamath & Tyler Gillam, DigitalOcean thumbnail

· 15:54

Preferences Over Benchmarks: Model Routing — Archana Kamath & Tyler Gillam, DigitalOcean

The talk argues that relying on public benchmarks to select a single best LLM is flawed; model selection must be based on specific operational preferences. The solution presented is an Inference Router—a purpose-built Mixture of Experts (MoE) model that dynamically selects the optimal LLM for each request based on declared constraints, including task type, cost tolerance, required latency, and system prompts. This approach significantly reduces inference costs and improves performance stability compared to using a single premium model across all tasks.

Key takeaways

  1. Model selection must be preference-driven, not benchmark-driven 4:02

    The 'right' model depends on the specific request context (task, cost, latency) and cannot be determined by a single public leaderboard. For instance, classification may use a small open model for cost efficiency, while code review requires a frontier model for accuracy.

  2. Model orchestration is the new phase of cloud optimization

    Due to exploding inference costs and single-model risk, advanced model orchestration (like routing) is becoming a critical discipline for production applications.

  3. The router optimizes cost and speed per task

    In live demos, the router successfully matched tasks (e.g., code generation, test writing) to specialized models (e.g., GLM 5.2, Claude 3 Sonnet), resulting in significantly lower total session costs (e.g., 8 cents vs. 25 cents) while maintaining comparable quality.

  4. The router is customizable and open-source 5:20

    The solution runs on an open proxy plan and a purpose-built routing model (both open source), allowing users to define custom decision tree rules, set failover policies, and evaluate performance using internal metrics rather than external leaderboards.

Watch on YouTube Full article

What If Your Chip Design Team Moved Like a Single Body? — Abduallah Mohamed, AIDAChip thumbnail

· 16:46

What If Your Chip Design Team Moved Like a Single Body? — Abduallah Mohamed, AIDAChip

The talk argues that for large engineering teams (50+ people), organizational alignment is a greater bottleneck than individual skill or tool availability. In high-stakes domains like chip design, where failure costs can reach $50 million, the solution requires moving beyond simple agent tools to build a 'shared nervous system.' This system—a living graph of intent and constraints—ensures that all changes are tracked, validated by human approval, and prevent systemic failures (like truth drift or agents overstepping boundaries) before silicon is printed.

Key takeaways

  1. Alignment Beats Individual Skill

    In large teams, communication overhead grows quadratically with headcount. The most successful organizations are those most aligned, not necessarily those with the best individual engineers.

  2. The Cost of Failure in Chip Design 5:47

    Chip design is irreversible; fixing errors requires re-printing silicon, incurring an average risk cost of $50 million per company. Practitioners report spending 70% of their time on alignment rather than development.

  3. The Shared Nervous System Solution 8:52

    Instead of scattered knowledge and fragmented intent, the solution is a multi-layer AI system built around a 'living graph' (the system of intent) that captures all constraints and decisions, requiring human approval for any agent modification.

Watch on YouTube Full article

FinOps for AI Agents: Who Spent All the Tokens? — Tisha Chawla & Susheem Koul, Microsoft thumbnail

· 21:24

FinOps for AI Agents: Who Spent All the Tokens? — Tisha Chawla & Susheem Koul, Microsoft

The talk introduces TokenOps, a control plane designed to shift AI agent development from 'token maxing' (spending tokens) to 'value maxing' (maximizing value per token). It addresses the critical gap in current systems: the lack of cost governance between code execution and model calls. TokenOps operates out-of-band at the entire agent run level, utilizing a `boundary annotation` and `governor node` to implement sophisticated policies that can 'steer' an agent's behavior (e.g., instructing it to be more succinct) before hitting a budget cap, thereby preventing costly failures.

Key takeaways

  1. Shift from Token Maxing to Value Maxing

    The industry needs to move beyond simply spending tokens and focus on ensuring that every token spent has measurable business value. This requires proper attribution of costs back to specific agent runs.

  2. Run-Level Cost Control is the Missing Piece 2:38

    Existing tools (like model gateways) only control cost at the request level. TokenOps provides governance at the entire agent run layer, allowing control over complex loops and context growth.

  3. Steering vs. Halting

    Instead of simply halting an agent when a budget is exceeded (a circuit breaker), the 'steer' action uses a cost guard to predict overruns and injects instructions into the system prompt, guiding the agent toward more efficient outputs.

Watch on YouTube Full article

Give the Agent a Budget, Not a Token — Sachin Malhotra, Anthropic thumbnail

· 19:53

Give the Agent a Budget, Not a Token — Sachin Malhotra, Anthropic

The presentation argues that granting AI agents 'unbounded power' via simple tokens is dangerous. Instead of narrowing the token scope (a boolean fix), engineers must implement a comprehensive 'budget' system with four dimensions: how much, how fast, what can be undone, and who notices. Key solutions include using asymmetric verbs (prioritizing loud failures), enforcing rate limits on writes, implementing trip wires over static allow lists, and utilizing an 'undo test' to size the overall safety policy.

Key takeaways

  1. Budget vs. Token 7:03

    A token is a boolean (yes/no) scope; a budget is multi-dimensional, considering volume, velocity, reversibility, and observability. The failure was giving the agent unbounded power, not the model itself.

  2. Asymmetric Verbs 10:05

    Prioritize granting agents access to operations that fail loudly (e.g., unskipping a test, which causes CI to go red) and keep critical failure verbs (like skipping a test) reserved for human intervention with an audit trail.

  3. Rate Limits & Trip Wires 13:54

    Implement rate limits on every write operation, ensuring the ceiling refills automatically. Use trip wires (monitoring aggregate behavior) instead of static allow lists, as trip wires adapt to real-world data.

  4. The Undo Test

    This test asks if the agent can autonomously roll back its own changes and what the blast radius would be if it failed. If not, a second key (human involvement) and an audit record are required.

Watch on YouTube Full article

Building Agents Is Trivial Now, Context Is the Next Frontier — Jeff Ng, Unblocked thumbnail

· 13:22

Building Agents Is Trivial Now, Context Is the Next Frontier — Jeff Ng, Unblocked

While cloud primitives and frameworks have made defining AI agents trivial—reducing complexity from requiring dedicated systems for checkpointing, sandboxing, and observability—the primary failure point remains missing organizational context. The speaker argues that simple access layers (like Multiple Connectors/MCPs) are insufficient because 'access is not understanding.' A Context Engine solves this by connecting disparate data sources (docs, code, tickets, conversations) to provide a synthesized, task-relevant understanding that agents can act upon, preventing critical errors and outages.

Key takeaways

  1. Agent Development Complexity Has Decreased

    Six months ago, building an agent required significant effort to solve infrastructure problems like state persistence (checkpointing), isolated sandboxes, and observability. Modern cloud primitives (e.g., Cloudflare, Vercel) have absorbed this 'plumbing,' simplifying agent definition to selecting a model, instructions, tools, and sandbox location.

  2. The Context Gap is the New Bottleneck 7:01

    Agents struggle with institutional knowledge—the decisions, failures, and postmortems stored across different systems (Slack threads, documentation). An agent lacking this full picture can make confidently wrong recommendations, potentially causing outages.

  3. Context Engines Provide Synthesized Understanding

    A Context Engine goes beyond simple data access by building a model of the organization. It reconciles conflicting results across multiple datasets (docs, code, tickets, conversations) and delivers a synthesized understanding that an agent can act on, rather than just raw documents.

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

Agentic SDLC at Uber — Uday Kiran Medisetty & Adam Huda, Uber thumbnail

· 18:26

Agentic SDLC at Uber — Uday Kiran Medisetty & Adam Huda, Uber

Uber has implemented a comprehensive 'Software Factory' powered by agentic AI to revolutionize its SDLC. Key infrastructure investments include a centralized Model Gateway for security and latency control, an MCP Gateway for token optimization, and a Context Graph that unifies knowledge across disparate systems. These building blocks enable autonomous agents (like Minion) to accelerate development from idea generation (via Cortana) through drafting PRs, validating changes in inner loops (e.g., comparing simulator screenshots against Figma specs), and managing maintenance tasks.

Key takeaways

  1. Agentic Adoption Metrics

    Over the last year, agentic AI led to more than 70% of Uber's Pull Requests (PRs) originating from local or cloud agents, resulting in double the lines of code per engineer year-over-year.

  2. Model Gateway Performance 2:06

    The Model Gateway handles all internal model calls through a single endpoint, ensuring PII redaction for over 20 types and running five specialized safety models under a strict 100 millisecond guardrail budget. It processes over 100 million requests daily across 800+ projects.

  3. Token Optimization 5:51

    The MCP Gateway, combined with projecting MCPS into CLI patterns and using Omni MCP, cut fleetwide token usage by more than 40%.

Watch on YouTube Full article

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

· 22:50

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

The talk addresses the critical shift from making AI agents more intelligent to making them safer and more autonomous. The core challenge is that as agents investigate complex issues (like latency spikes), their required access expands at runtime, significantly widening the 'blast radius.' The speaker proposes a new runtime layer designed to manage this complexity by enforcing three pillars: **Containment** (running the agent in an untrusted boundary while controls remain outside), **Scoped Capabilities** (providing only the minimum necessary access for a specific task), and **Intent-Based Access** (determining if the requested action aligns with the original user intent). This runtime must be portable across all environments (local, cloud, VPC) and models.

Key takeaways

  1. The Shift from Intelligence to Safety

    The next major challenge in agent development is not intelligence, but safety. Traditional software had fixed permissions; autonomous agents change their required access at runtime, necessitating a fundamental shift in security architecture.

  2. The Danger of Expanding Scope 5:12

    When an agent investigates a problem (e.g., latency spike), it sequentially requests access to logs, GitHub history, and Slack. Each step expands the trust boundary, leading to a single process with excessive, accumulated permissions.

  3. The Three Pillars of Safe Autonomy 10:24

    A proposed runtime layer must implement: 1) **Containment** (controls outside the agent's boundary); 2) **Scoped Capabilities** (providing granular access per task, not accumulating them); and 3) **Intent-Based Access** (validating if a sudden request—like email access during an incident investigation—is correct or should be escalated).

  4. Portability and Orchestration 22:38

    The runtime must be omnipresent, working across different models (Anthropic, Claude, Open Code), multiple harnesses, and environments (local machine, cloud VPC). The speaker demonstrated that the same secure sandbox can run locally or in the cloud, and these sandboxes can be composed for parallel execution and orchestration.

Watch on YouTube Full article

Your Fine-Tuned Model Is Tech Debt: A 50x ROI House of Cards — Dan Bjornn, Lease End thumbnail

· 16:39

Your Fine-Tuned Model Is Tech Debt: A 50x ROI House of Cards — Dan Bjornn, Lease End

The video argues that relying heavily on fine-tuned LLMs for production applications can create 'calcification tax'—a form of technical debt characterized by rigid architecture and complex maintenance cycles. The speaker details migrating from a fine-tuning approach to an agentic framework built on skills, prompts, and context. This shift drastically reduced the time required to deploy fixes (from weeks/days to under an hour), improved accuracy, maintained model agnosticism, and ultimately lowered total operational costs.

Key takeaways

  1. The Calcification Tax 10:04

    Fine-tuning creates technical debt by locking systems into specific models and architectures. The complexity of retraining—which involves gathering examples, synthesizing data, manual validation, and iterative fixing—is costly and slow (up to a week per cycle).

  2. Agentic Frameworks Over Fine-Tuning

    The rebuild swapped the fine-tuned model for skills, prompts, and context on a model agnostic framework. This allowed fixes to ship by simply uploading files to an S3 bucket.

  3. Cost vs. Accuracy Tradeoff

    While the new agentic approach increased cost per message (due to using better models), overall total cost decreased significantly because the time spent on maintenance and retraining was drastically reduced.

Watch on YouTube Full article

How I automate my own job at Hugging Face using agents — Niels Rogge, Hugging Face thumbnail

· 20:37

How I automate my own job at Hugging Face using agents — Niels Rogge, Hugging Face

Niels Rogge details how he automated his role at Hugging Face—the 'Google Drive to the hub' team—which focuses on improving the discoverability of machine learning artifacts. He built two systems: an initial deterministic workflow for outreach (using cron jobs and LLM APIs) and a subsequent fully autonomous agent loop for follow-up actions. The architecture leverages modern tooling like Modal, Bash CLI skills, and advanced models (e.g., GLM 5.2) to scale the process of identifying missing artifacts and prompting researchers to publish them on Hugging Face.

Key takeaways

  1. The Problem: Artifact Discoverability

    ML weights and datasets are often published on third-party services (Google Drive, Zenodo) rather than the centralized platform (Hugging Face), hindering discoverability. The goal is to automate outreach to authors.

  2. Initial Automation: Deterministic Workflow 11:43

    The first phase used a deterministic workflow, running as a nightly cron job on GitHub Actions. This approach utilized LLM APIs in predefined steps without an agent framework, offering high predictability and control.

  3. Advanced Automation: Autonomous Agent Loop 15:36

    The follow-up process was automated using a fully autonomous agent loop (e.g., leveraging the Claude agents SDK). This flexible approach allows the agent to use tools and skills, such as Bash and the Hugging Face CLI, to interact with GitHub issues.

Watch on YouTube Full article

The Era of Compound Engineering — Kieran Klaassen, Every/Cora thumbnail

· 20:38

The Era of Compound Engineering — Kieran Klaassen, Every/Cora

The talk introduces 'Compound Engineering,' a methodology for building complex software products using AI by shifting focus from writing code to optimizing the system's memory and knowledge base. The core principle is that development efficiency increases when time is spent teaching the AI what it got wrong (system refinement) rather than just generating new features. This process inverts complexity accumulation, aiming for each subsequent feature to be easier to build than the last.

Key takeaways

  1. The Compound Engineering Loop 10:25

    The development loop involves Brainstorming $\rightarrow$ Planning $\rightarrow$ Working $\rightarrow$ Reviewing $\rightarrow$ Polishing $\rightarrow$ Compounding. The human must be 'brain-on' at both the start (defining the problem) and the end (raising the bar/taste).

  2. The 50/50 Rule of Improvement 13:30

    Allocate 50% of time to building the feature and 50% to teaching the system what it did wrong or how it can learn. This knowledge extraction is crucial for long-term efficiency.

  3. Token Efficiency through Memory 15:03

    Storing solutions and learnings within a repository (compounding) makes future interactions more token-efficient because the AI does not need to perform deep research or correction passes; the solution is already embedded.

  4. Inverting Complexity 20:38

    The goal of Compound Engineering is that each shipped feature makes the next one easier, counteracting the typical accumulation of complexity in software development.

Watch on YouTube Full article

IT Admin for the AI Workforce — Sarthak Aggarwal, Decawork thumbnail

· 16:17

IT Admin for the AI Workforce — Sarthak Aggarwal, Decawork

Enterprises are adopting autonomous AI agents as a 'second workforce,' shifting focus from model behavior to operational safety and governance. The core challenge is managing agents that possess tools, private data, and delegated authority. To mitigate risks—exemplified by incidents like the Replit breach and zero-click CVEs like EchoLeak—the architecture must implement robust identity standards and strict privilege separation, ensuring that planning (intent) is separated from execution (action).

Key takeaways

  1. Capability vs. Employment Readiness 1:48

    A working demo only proves capability; it does not prove employment readiness. An agent with a goal, tools, private data, and delegated authority acts as an 'actor,' requiring governance controls like identity, owner definition, policy scoping, and reliable revocation.

  2. The Need for Agent Identity Standards 4:08

    Current identity systems (like OAuth token exchange) provide the right shape but lack a dedicated agent identity standard. Agents require a defined lifecycle—provisioning, authorization, monitoring, and revocation—mirroring human employee management.

  3. Privilege Separation Architecture

    To ensure bounded authority, the system must separate trusted intent from untrusted content processing. The Planner turns authenticated intent into a typed, logged plan, while the Executor runs that plan without holding standing credentials, preventing actions outside the defined scope.

Watch on YouTube Full article

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

· 18:18

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

The speaker argues that autonomous AI agents have fundamentally changed the role of a leader, transforming 'building' from an extracurricular activity into a core job function. By leveraging overnight development loops, leaders can now prototype features, optimize LLM calls, and train custom models with minimal hands-on time. Success hinges on establishing robust organizational scaffolding, including trustworthy CI, feature flags, and rigorous code hygiene.

Key takeaways

  1. Building is Now Part of the Job

    Due to autonomous coding agents, the manager's schedule can now be used for building. This shift allows leaders to stay current with rapidly changing frontier models and demonstrate capabilities via working prototypes rather than just theoretical discussions.

  2. The Overnight Development Loop 10:56

    A core workflow involves a 'co-worker agent' gathering context (from Slack, Jira, Notion) into a comprehensive prompt. This prompt is then handed to a coding agent overnight (4–8 hours), resulting in a report and a functional package ready for review the next morning.

  3. Judgment Remains Human 7:05

    While modern models excel at execution, they are not yet reliable at judgment. Leaders must provide high-level context and strategic direction to guide the agents effectively.

Watch on YouTube Full article

The Last Human Code Review: Building Trust in AI-Generated Code — Itamar Friedman, Qodo thumbnail

· 18:54

The Last Human Code Review: Building Trust in AI-Generated Code — Itamar Friedman, Qodo

The bottleneck in modern software development is shifting from writing code to managing governance and context within the Software Development Life Cycle (SDLC). The speaker argues that AI models are no longer the primary constraint; instead, the critical challenge is codifying 'tribal knowledge'—the undocumented best practices, architectural contracts, and historical failure data held by senior developers. Future code review must transition from line-by-line diff checking to reviewing a comprehensive software graph that tracks inter-service dependencies and potential contract breaks across multiple concurrent Pull Requests (PRs).

Key takeaways

  1. The Bottleneck Shift

    The primary bottleneck is no longer writing code, but rather the governance layer within the SDLC. Organizations must address how to automate or enhance code review processes that validate architectural standards and business intent.

  2. Two Competing Philosophies 5:38

    Engineering leaders are split into two camps: those who insist every line of code requires human trust/review, and those who prioritize velocity by shipping bugs quickly and fixing them post-deployment. The chosen philosophy dictates the necessary tooling and governance strategy.

  3. Context is the Constraint 8:39

    The limitation is not model reasoning ability; it is the scattered nature of context—which resides across competing instruction files, internal team standards, and undocumented knowledge held in developers' heads or Slack threads. Codifying this context is paramount.

Watch on YouTube Full article

Why Your Enterprise Tech Stack Isn’t Ready for AI Agents — Christopher Lovejoy & Saul Howard thumbnail

· 19:15

Why Your Enterprise Tech Stack Isn’t Ready for AI Agents — Christopher Lovejoy & Saul Howard

The talk addresses why traditional enterprise tech stacks are insufficient for deploying AI agents in highly regulated industries like healthcare. The core argument is that focusing on achieving high accuracy during a Proof of Concept (POC) often leads to architectural debt when attempting productionization. To build scalable, compliant systems, engineers must prioritize non-functional requirements—specifically auditability, data security, and human oversight—from the outset. This requires adopting specialized primitives: immutable event logs, schema-driven object storage for sensitive data, and treating humans and models as equivalent agents.

Key takeaways

  1. Audit Trail vs. Developer Log 0:05

    In regulated environments (e.g., HIPAA, SOC 2), an audit trail must be a complete record of every action taken by the agent, every place it accessed data, and the authorization behind each step—not merely a developer log like those found in DataDog [5:19].

  2. Prioritize Constraints Over Accuracy 0:12

    Engineers should take regulatory constraints seriously first (e.g., auditability) and design the architecture around them, rather than bolting compliance requirements onto a high-performing POC [12:07].

  3. The Three Architectural Primitives 0:08

    Effective AI agent systems require three core primitives: an immutable append-only event log (for state tracking), schema-driven object storage (for data separation and Zero Trust), and human/model agent equivalency (for seamless escalation) [8:30].

  4. Evals as a Byproduct 0:10

    By implementing these three primitives, robust evaluation (evals) can emerge naturally—allowing for action replay, testing on production data without exposure, and comparing human vs. model performance—rather than being an afterthought [10:37].

Watch on YouTube Full article

Don’t be data poor — Anuj Iravane, Anterior thumbnail

· 16:46

Don’t be data poor — Anuj Iravane, Anterior

The talk addresses the critical problem of 'data poverty' in highly regulated domains like healthcare, where the most valuable data (Patient Health Information or PHI) is ephemeral and legally prohibited from being retained, anonymized, or derived for dataset creation. The core solution presented is synthetic data generation. This process involves reversing the standard inference workflow—starting by sampling a desired label and reasoning trace, and then generating the necessary unstructured medical record that would have produced it. The resulting pipeline uses an LLM-based, coarse-to-fine approach, ensuring high fidelity while maintaining domain expert control.

Key takeaways

  1. Reverse Inference for Data Generation 5:20

    Instead of running the forward task (Unstructured Data + Policy $\rightarrow$ Label), the method reverses this by sampling a label and a reasoning trace first, then generating the input data that supports it. This circumvents the diversity problem inherent in standard LLM generation.

  2. Domain Expert Ownership (Human-in-the-Loop) 11:30

    To ensure generated data is useful, domain experts (clinicians) must own the pipeline. This is achieved by enabling them to interject at any point in generation and modeling the entire workflow as a skills-based system running on an agent harness.

  3. Synthetic Data Fidelity 14:35

    The generated data can be highly accurate, with early results showing that in a blind review, clinicians were only able to distinguish synthetic from real records about 60% of the time.

Watch on YouTube Full article

How to build an AI-Native Health Company — Dan Feng, Maven Clinic thumbnail

· 17:19

How to build an AI-Native Health Company — Dan Feng, Maven Clinic

The transition to an AI-native company requires a fundamental shift in process and culture, moving away from lengthy planning cycles toward rapid, iterative development. While building software is now fast (minutes), the expense lies in arguing requirements. Build engineers must adapt by adopting short-cycle planning (2–4 weeks) and implementing rigorous, multi-layered testing strategies to manage AI-specific risks like hallucination. Key process changes include limiting Pull Request (PR) size (capped near 500 lines) and running integration tests multiple times to ensure reliability.

Key takeaways

  1. Shift Planning Focus 10:32

    Instead of spending weeks or months finalizing requirements, focus on delivering value in the next two to four weeks. Long-term plans (1 year) should only serve as directional inspiration, not rigid commitments.

  2. Redefining Code Review

    Due to increased code output from AI tools, traditional code review must change. Engineers can self-certify simple PRs, and large features should be stacked into multiple smaller PRs (capped near 500 lines) to maintain meaningful review quality.

  3. AI Reliability Testing

    For GenAI solutions, failure modes must be categorized (tolerable vs. not acceptable). Critical processes require consensus among multiple models (e.g., using different LLMs to review the same receipt) and running integration tests many times, rather than just once.

Watch on YouTube Full article