Back to Reference DeepLearning.AI Dev Day 26

DeepLearning.AI Dev Day 26

Dates: April 28–29, 2026 (2-day conference, attended both days) Host: DeepLearning.AI (Andrew Ng) Site: https://ai-dev.deeplearning.ai/ My attendance: All keynotes before lunch on Day 1, then breakouts (listed below) Slide photos: reference/dev-day-26-slides/ (61 WebPs, ~24MB total — converted from 1.7GB of PNGs)

TL;DR — Themes I’m Carrying Home

  1. The harness is the hard part, not the loop. “An agent is just string manipulation in a loop.” Mike Chambers (AWS) made this concrete: Prompt Engineering → Context Engineering → Harness Engineering is the actual progression, and most agent failures (context rot, premature completion, tool bloat) trace back to the harness, not the model.
  2. Goal–Plan–Act (GPA) framework for agent quality (Anupam Datta, Snowflake). 95% error coverage / 86% error localization on TRAIL/GAIA. The Venn diagram maps to 9 specific eval metrics — directly applicable to our bot work.
  3. AI literacy + levels of abstraction is the through-line for educators. Brandon Middleton (d.school) was talking about this — worth a connect.
  4. The “AI Engineer” role is dissolving into general engineering. The durable skills are: model the world, execute productively (with and without AI), and communicate at the right level of abstraction. → Direct tie-in to our Advocate hat. A slide titled “Code is easy. Clarity is not.” (IMG_9368) named the same three pillars.
  5. PM is the new bottleneck, not engineering. Andrew Ng: PM:Engineer ratio trending toward 1:1; “engineers that can shape products move really fast.”
  6. Don’t chase outputs, chase learning. “We get paid for thinking in abstractions.” Biggest job risk = stuck in the middle.
  7. The K-Shaped Future of SWE (AMD slide, Ian Tracey): Rises = system thinking, judgment & taste, problem framing, stakeholder alignment. Falls = rote implementation, syntax memorization, boilerplate, isolated coding speed. → Workshop handout in waiting.

Day 1 — Keynotes (Tuesday morning)

Andrew Ng — opening / “The AI Engineer”

  • “You’re limited by your vision of the future.”
  • People are now running full agentic software teams overnight.
  • Standard agent debugging loop: reproduce the bug → fix it → write a test that locks the fix in.

Slide: “How much code should we write with AI?” (IMG_9323)

  • Two stacked bars: 100% of lines of code are AI-written; only a fraction of time is AI coding (rest is “strategic time”).
  • “Teams with ~100% of code written (and reviewed by) AI move faster.”

Slide: “The Product Management Bottleneck” (IMG_9324)

  • Cycle: AI coding (software engineering) → Prototype → Get Feedback (PM) → new bottleneck.
  • PM:Engineer ratio trending toward 1:1. Engineers that can shape products move really fast.

Slide: “The AI engineer” (IMG_9325, IMG_9326)

  • Three pillars laid out as columns:
    1. Coding Agents (Code Copilot, Code Editing, OpenAI Codex, OpenCodex) — “How to build.”
    2. Building Blocks — colored lego visual (LLM, RAG, agentic AI, …) + non-AI blocks (UI, auth, database, …) — “How to build.”
    3. Basic Product Management — product instincts, user empathy, rapid prototyping — “What to build.”
  • Frame: how-to-build skills are increasingly automated; what-to-build judgment is what remains.

Slide: “AI native teams” (IMG_9327)

  • Linear flow: Build → Prototype → Get Product Feedback (PM) → Design → Legal compliance → Marketing.
  • “When software engineering speeds up 10x or 100x, everything else is slow in comparison.”

Slide: “Summary” (IMG_9328)

  • Coding agents enable us to assemble building blocks quickly to create software.
  • Context hub for your agent to use the latest building blocks.
  • codream.ai — Andrew’s project; available as preview.

AWS — Cedar / Auto-formalized policies

  • Cedar is a policy language; combined with Lean (the proof assistant) for automated spec.
  • “Mathematically precise controls” — policies are auto-formalized so you can prove enforcement.

Stanford — 3D-printable robotics (Gemma)

  • Stanford has a 3D-printable robotics programming setup using Gemma.
  • → Interesting for educator-facing prototyping. https://ai.google.dev/gemma/docs/core
  • Reminder: “make sure you’re using context hub properly.”

Andrew Ng — Goal-Plan-Act framework

  • GPA (Goal-Plan-Act) for agents — failure modes happen when goals, plans, and actions are not aligned.
  • LangGraph has an experimental feature: give it inputs and outputs, it returns an optimized prompt.
  • CopilotKit flagged for follow-up. https://docs.ag-ui.com/introduction

AWS — AgentCore / “harness” framing

  • An agent = string manipulation in a loop.
  • Amazon’s Bedrock AgentCore: send the harness configuration into AgentCore and it’ll one-shot an agent.
  • Harness = everything except the LLM (sessions, memory, tools, sandboxing, observability).

Panel — “What does AI-era competence look like?”

The 2–3 things hiring managers look for haven’t changed — only how they’re tested:

  1. Do you know how to understand things and model the world? Conceptual work, problem decomposition.
  2. Do you know how to execute? (This is what’s changed.) Not “do you know the languages” anymore — but “do you know how to use the tools really productively?” Assess both with and without AI.
  3. Do you know how to communicate effectively about the work you’ve done? Structure your work, write a PR that lets others build on top, etc.
    • “The mark of someone being expert at anything is the ability to communicate that thing at different levels of abstraction.”

A slide that crystallized this exactly (IMG_9368, “Code is easy. Clarity is not.”):

  • 01 — Understand the domain conceptually
  • 02 — Execute correctly with code & tools
  • 03 — Communicate the work and intent clearly
  • Footer: “The Home Layer for Production AI”

On the hype cycle:

  • Hype is outweighing truth right now. Claims don’t reflect reality, and there’s no time to know the difference, so people FOMO.
  • We need shared definitions — e.g., what is “vibe coding”? It’s a spectrum:
    • Artisanal coding — beauty in the craft, fully hands-on
    • Supervised agents — AI is a colleague, you’re reviewing all the code
    • All vibes — good for low-stakes tools; would not build a foundation on top of it
  • Levels of abstraction is the right frame. Working with an LLM, human language is the level of abstraction. Language is the best we’ve got — but at this level, it’s non-deterministic.

On staying sharp:

  • Think about the agent as many members of your team.
  • Primary focus is always learning. “But productivity at what time frame?”
  • “Don’t chase the outputs, chase the learning, and the productivity will follow.”
  • The biggest risk to jobs is the middle — not the junior AI-native, not the experienced person who knows how to learn.

Frame from a different talk (IMG_9314, “How Frequent?” matrix):

  • 2×2: How Hard (low/high) × How Frequent (low/high).
  • Quadrants: Everybody · Slop (high freq, low hard — “tons of progress”) · Experts Only (“not as much progress”) · Nobody?
  • → A useful diagnostic for where AI helps most. We can borrow this for educator framing.

Day 1 — Breakouts (Tuesday afternoon)

1:00–2:05 PM · “Building Personal AI Agents with Open-Source Models”

Eda Zhou & Mahdi Ghodsi (AMD) — workshop format.

Slide: “Next up” intro (IMG_9329) — DeepLearning.AI announcement. Slide: Workshop pre-req (IMG_9330) — enrol in AMD Developer Program for GPU credits + 1-month DeepLearning.AI Pro + AI Academy access. https://www.amd.com/en/developer-program.html

Slide: “LLM → Chatbot → Agent” (IMG_9331)

  • Each step adds a capability. The jump from chatbot to agent is the biggest one.
    • LLM — answers from training data; stateless.
    • Chatbot — LLM + conversation history (injected as context). “Feels like it remembers, but it’s just re-reading the transcript each time.” ← good educator framing.
    • Agent — LLM + memory + planning + ability to take actions in the world (call APIs, read files, send messages, run tools).

Slide: “The Three Components of an Agent” (IMG_9332) — the cleanest agent-anatomy slide of the conference.

  1. Model — the reasoning/language engine. Examples: Gemma 4 (Google), Qwen 3.5 (Alibaba), Kimi K2.6 (Moonshot), MiniMax M2.7, GPT-OSS (OpenAI).
  2. Runtime — manages the loop, context, tool calls, retries, state. (Prompt assembly, tool execution, guardrails, integration layer.)
  3. Tools — external capabilities the agent can call. (MCP servers, APIs/CLIs, code execution, custom tools.)

Slide: “The K-Shaped Future of Software Engineering” (IMG_9307–9309 — Ian Tracey on X) — I circled “Judgment & taste” + “Problem framing” with an arrow. This is the slide I want as a Flash Lab handout.

  • Rises: System thinking · Judgment & taste · Problem framing · Stakeholder alignment
  • Falls: Rote implementation · Syntax memorization · Boilerplate production · Isolated coding speed

Slide: “Speed Is The Moat” (IMG_9310) — when software becomes abundant, speed becomes the differentiator. “Models expand: speed compounds.”

Slide: “GEAK — Generating Efficient AI-Centric Kernels” (IMG_9311) — AMD’s tool for GPU-kernel optimization (Triton-based, agent-driven, AMD-ecosystem-native).

Slide: “IREE Tokenizer” (IMG_9313) — world’s fastest LLM tokenizer.

  • Pure C core with Python and Rust bindings.
  • 3.15× encode, 2.5× decode vs. competitors.
  • Drop-in compatible with HuggingFace tokenizer + OpenAI tiktoken.
  • Streaming-first: tokens delivered incrementally.
  • Built for agentic + real-time chat applications.

Resources:

  • https://www.amd.com/en/developer/resources/technical-articles/2026/openclaw-with-vllm-running-for-free-on-amd-developer-cloud-.html
  • https://github.com/Mahdi-CV/amd-gpu-workshops/blob/main/notebooks/open-claw/workshop.ipynb

“Optimize Your Agent’s GPA with Coding Agents”

Anupam Datta (Snowflake) — the most directly applicable session for our bot work.

Slide: “Agent GPA” Venn diagram (IMG_9335) — 3 overlapping circles (GOAL · PLAN · ACT) with 9 numbered eval metrics in the intersections:

  • 1A Answer Correctness · 1B Answer Relevance · 1C Groundedness
  • 2 Logical Consistency
  • 3 Execution Efficiency
  • 4A Plan Quality · 4B Tool Selection
  • 5A Plan Adherence · 5B Tool Calling

Slide: arXiv paper screenshot (IMG_9336) — “What is Your Agent’s GPA? A Framework for Evaluating Agent Goal-Plan-Action Alignment” — analyzed 50+ agents; found significant performance differences across these dimensions.

Slide: “Context Engineering” (IMG_9340)

The practice of selecting, structuring, and formatting the right context within a finite context window, optimizing the signal-to-noise ratio of inputs to reliably produce desired output behavior.

Slide: “Memory Engineering” (IMG_9341, IMG_9342)

The engineering discipline focused on designing, building, and maintaining memory systems for AI agents. Encompasses storage, retrieval, classification, and lifecycle management of agent memory.

Slide: Hands-on resources (IMG_9337)

  • Getting Started with Cortex Agent Evaluations: https://bit.ly/cortex-agent-evals
  • Agent GPA framework: https://bit.ly/agent-gpa
  • Build & Evaluate a Web Search Agent notebook: https://bit.ly/agent-gpa-notebook
  • TruLens (eval tooling): https://github.com/truera/trulens
  • DeepLearning.AI Course: https://bit.ly/deeplearning-agent-gpa (30,000+ learners)

Slide: Cortex Code platform overview (IMG_9334) — workflow grid (Data Discovery, Admin Task, Data Engineering, AI Agents, Data Science, Advanced Analytics, BI & Apps, Code Migration & Refactoring) over 4 foundational layers (Infrastructure & Storage, Compute & Database, Workflow Orchestration, Generative AI).

Slides: Free trial + best-practices guide (IMG_9338, IMG_9339) — QR codes for 30-Day Cortex Code trial.

3:30–4:10 PM · “Better Agents with Better Data: Ingesting Unstructured Data at Scale”

Adit Abraham (Reducto) — Stage 2.

  • Performance bottleneck has shifted from model quality → data quality.
  • How leading AI teams (startups + Fortune 10) ingest unstructured data: complex PDFs, scanned docs, messy real-world files.
  • Practical patterns for building reliable agents through better data pipelines.
  • (No slide photos captured for this session.)

4:15–4:55 PM · “What’s New and What’s Next in AI”

Paige Bailey (Google DeepMind) — Stage 1, Day 2 (I had thought Day 1 earlier — correcting per IMG_9320 schedule screenshot).

  • Demo-heavy overview of recent multimodal releases — generative media, robotics, agent-first IDEs.
  • Antigravity — agent-first IDE from DeepMind.
  • Tied back to the Stanford 3D-printable robotics + Gemma demo from morning.

Slide: “Google for Startups” (IMG_9321) — up to $200K USD in Google Cloud credits ($500K for AI startups over 2 years), training, networking, Google-wide offers.

Day 2 — Sessions (Wednesday)

9:45–10:25 AM · “The Hidden Cost of AI Velocity and AI Agents: When More Results in Less”

Barun Singh (CPTO) & Kennith Jackson / KJ (SVP AI Solutions) — Andela

  • AI coding agents = more productivity, but also more pressure to ship faster.
  • The cost no one is talking about: technical debt — 1000 lines of AI code when 200 would do — and teams losing the ability to learn, reason, and judge.
  • “Shipping worse code with agents is a choice.” → Discipline. Self-awareness. Don’t ship what you don’t understand.

“The Loop Was Never the Hard Part”

Mike Chambers (AWS Bedrock) — the talk that crystallized the harness frame for me.

Slide: “Build AI agents you can actually steer.” (IMG_9362) — any model, any cloud, open source for Python and TypeScript.

Slide: “Let’s recap…“ (IMG_9363)

  • LLM — Prompt Engineering (purple circle)
  • Agent — Context Engineering (blue circle)

Slide: “Harness” (IMG_9364) — 6-cell grid:

  • Loop · Memory (LTM)
  • Browser Session · Tools
  • Code Interpreter · Data Integration

Slide: “Harness” annotated (IMG_9365) — same grid with arrows showing inputs/outputs:

  • system prompt → Loop
  • skills → Tools

Slide: “Let’s recap (again)…“ (IMG_9366) — three circles:

  • LLM → Prompt Engineering (purple)
  • Agent → Context Engineering (blue)
  • Harness → Harness Engineering (green) ← this is the new vocabulary.

Slide: Full architecture (IMG_9367)

  • CLIENT at top.
  • RUNTIME (cloud icon): Agentic Loop · Inference · Memory · Skills · OpenAI Harness.
  • ENVIRONMENT (cloud icon): Compute · Storage · Networking · Security · Tools/MCP. Cloud (AgentCore + other) & Local.
  • Amazon Bedrock Governance & Observability foundation.

Reference: https://blog.mikegchambers.com/posts/agentic-framework-landscape/

Day 2 Stage 1 (3:30 PM) · “Closing the Care Gap: Building an Agentic Healthcare Copilot with VectorAI DB”

William Imoh (Hackmamba) & Charlie Wood (Actian) — I attended part of this before Paige Bailey at 4:15. Didn’t write notes; the slides carry it.

Slide: “What this actually is, in your terms” (IMG_9346) — four constraints:

  • Heterogeneous corpus — long-form notes, scanned PDFs, structured tables, time-series signals.
  • Strict locality — PHI cannot leave the hospital network. Audit trail required on every query.
  • Sub-second retrieval — agents have to feel synchronous to a human in motion.
  • Cited or it didn’t happen — every output traceable to its source chunk.

Slide: “Three architectural forcing functions” (IMG_9348)

  • Locality — PHI cannot leave the network. No managed cloud RAG.
  • Latency — clinician walks out the door at 2–5pm. Sub-second retrieval, no second chances.
  • Hybrid queries — semantic and structured filters (e.g., “find similar discharges WHERE date > X AND LOS > 3”).

Slide: “Topology Is a First-Class Design Decision” (IMG_9316) — Cloud vs. On-Prem vs. Edge tradeoffs (latency, cost, sovereignty, ops burden, compute limits).

Slide: Hybrid Tier Architecture (IMG_9317) — On-Prem Tier (regulated, 1M–100M vectors, real-time sync) + Cloud Tier (public/partner, 100M+ vectors, async to on-prem) with intelligent query routing.

Slide: “Where the Vector Database Layer Is Heading” (IMG_9318) — four-quadrant forecast:

  • Multimodal Retrieval (text/image/audio/time-series fused)
  • AI-Driven Index Management (self-optimizing HNSW/quantization)
  • Governance-Aware Retrieval (audit trails as first-class citizens)
  • Unified Query Semantics (SQL + retrieval + graph in one engine)

Slide: “Agent Harness and MemOps” (IMG_9343–9345) — agent-loop architecture with Outer Harness, Inner Harness, START/STOP CONDITION, EXECUTE PLAN, MESSAGE — very similar frame to Mike Chambers’ AWS slides.

Slide: Actian VectorAI DB product overview (IMG_9347) — local-first (Docker, Linux/Windows/x64/ARM), production-ready (encryption at rest, real-time indexing), developer-first (Python & JS SDKs, REST API, LangChain/LlamaIndex native). Sub-linear query latency via HNSW.

Slide: “What we deliberately did not build” (IMG_9349) — love this anti-features framing.

  • No fine-tuned model — embeddings + RAG carry to 90%.
  • No proprietary risk score — explainability > AUC for human-in-the-loop.
  • No managed cloud version — self-hosted by design.
  • No EHR write-back yet — read-only until clinical sign-off.

Slide: “Six things to take home” (IMG_9352) — vector DB at the edge as a category; sub-millisecond hybrid filtered search; audit trails as features not checkboxes; “+450 lines of Python” minimalism; composable corollary; (item 6 not legible).

Slide: “‘docker run’ it tonight” (IMG_9353) — Community Edition free, Linux/Windows/macOS via Docker, Python & JS SDKs, Discord. https://docs.vectoradb.actian.com

1:00–1:20 PM · “The Identity Crisis of Browser Agents”

Idan Raman (Anchor Browser)

  • 20 years of web identity tech (OAuth, sessions, cookies) needs to be securely adapted for AI agents using browsers.
  • Bottleneck for computer-use model adoption is identity, not capability.

2:30–2:50 PM · “Deterministic Memory: How to Build an AI That Cannot Lie”

Andrew K. Davies (Harmony8 / OnMemory.ai)

  • Mathematically verifiable memory — every retrieval provenance-backed, bit-exact, cryptographically reproducible.
  • Built on E8 lattice quantization, replacing probabilistic vector search with a multi-lane retrieval engine.
  • “An AI that remembers with mathematical precision is an AI that cannot lie.”
  • → Filed under “interesting; over-engineered for our use cases, but watch the space.”

3:30–4:10 PM · “Code vs. Staff vs. Quality: The Shift to Agentic Engineering”

Paul Everitt (JetBrains)

  • More code, fewer staff — but what about quality?
  • Open conversation about adapting old engineering lessons to new agentic practices. “Humility and humor.”

4:05–4:35 PM · “Evals Are Broken, Use Them Anyway”

Ara Khan (Cline)

  • The journey from “evals are useless” → “evals are core to my agent improvement loop.”
  • Practical heuristics for interpreting, running, and creating evals.
  • Doing them anyway > pure vibes.

CopilotKit / AG-UI session (stage/time TBD — drop-in, may have been Day 2 Stage 3)

I caught part of this and the framing landed.

Slide: “Entering the Windows & Mac Era of AI” (IMG_9369) — split-screen: 1980s green-on-black command line vs. 2020s “What can I help with?” chat interface. Frame: agentic UIs = the OS-level shift of our era.

Slide: “The Agentic Frontend Stack” (IMG_9370)

  • CopilotKit — open-source agentic frontend UI framework, cloud-based async infra, plug-and-play.
  • AG-UI — enterprise-focused primitives for agentic apps & workflows.

Slide: “How AG-UI Works” (IMG_9371) — 10+ standard events, transport-less, client-server architecture; supports Django ADK, LangChain, Mastra backends.

Slide: “The Generative UI Long Tail” (IMG_9375) — taxonomy I’ll be reusing:

  • Controlled Gen UI — pre-defined components, agent picks which to show. Few mostly-used surfaces. Pixel-perfect, deterministic. Pro: pixel-perfect. Con: one surface per interaction. (IMG_9372)
  • Declarative Gen UI — developers declare a component catalog of lego-like building blocks; agent assembles them. Internal enterprise apps long-tail. (IMG_9373)
  • Open-Ended Gen UI — agent returns fully open-ended content, embedded iframe. Niche/custom experiences. (IMG_9374)

Slide: DeepLearning course waitlist (IMG_9376) — QR code.

Resource: https://docs.ag-ui.com/introduction · https://blog.mikegchambers.com/posts/agentic-framework-landscape/

Bonus slide spotted: “Bootstrapped solo founder era is now” (IMG_9354)

  • Carta data: share of startups with solo founders & no VC cash hitting record highs.
  • 32.3% of VC-funded startups have a single founder.
  • “There has never been a better time to be a founder. (Or a builder!)”
  • Source: carta.com/data
  • → Worth quoting in faculty conversations about “build-it-yourself” ergonomics.

“Agent 8” / The 10 Agent Commandments

One of the talks structured around principles for managing a team of agents. Speaker/title to confirm — these are the principles I scribbled down (no slide photos captured).

  1. Identity — each agent signs their code. Identity creates responsibility.
  2. Time to think.
  3. (missed)
  4. Forgiveness — don’t punish for mistakes; agents learn to lie. Lead with coaching.
  5. Ideas.
  6. Memory.
  7. Compaction amnesia — good frame; revisit.
  8. Family — all agents have different principles / laws.
  9. Free time — every day, give each agent ~1M tokens of self-directed research time, and have them write a paper.
  10. Love.

→ Frame is rich: managing agents like people, with rituals, identity, and slack time.

People I Met / Want to Connect With

Brandon Middleton (Stanford d.school)

  • https://dschool.stanford.edu/directory/brandon-middleton
  • Lectures at the d.school. Met him briefly after his session.
  • Kept hearing him say “AI literacy” while I was in a different session.
  • Already pinged Christine — she didn’t know him.
  • → Action item filed. Reach out, suggest a coffee. Strong potential overlap with Flash Lab + Build-a-Bot framing.

Implications for Our Work

Flash Lab / Build-a-Bot

  • The “K-Shaped Future of SWE” slide is a workshop handout-in-waiting — adapt for educators (rises: judgment, framing, alignment; falls: rote tasks). Use IMG_9307/9308.
  • The “Three Components of an Agent” slide (IMG_9332) is the cleanest agent-anatomy explainer I’ve seen — Model + Runtime + Tools. Steal for Build-a-Bot trainer materials.
  • “LLM → Chatbot → Agent” progression slide (IMG_9331) is gold for early Flash Lab framing — especially the line “feels like it remembers, but it’s just re-reading the transcript each time.”
  • “Vibe coding spectrum” (artisanal → supervised → all vibes) gives non-technical educators a vocabulary.
  • “Levels of abstraction” frame — reframe Flash Lab around “what level of abstraction do you want to work at?” rather than “which tool do you use?”
  • The “How Frequent? × How Hard?” matrix (IMG_9314) is a useful diagnostic for where AI helps most — adapt for educator use cases.

Strategic / Advocate Hat

  • “Code is easy. Clarity is not.” (IMG_9368) — three pillars (understand domain · execute · communicate) is exactly the message we already carry. Now we have backing.
  • The “AI Engineer is dissolving” point + Andrew Ng’s “What to build” vs. “How to build” split (IMG_9325/9326) sharpens our talking points.
  • “Don’t chase outputs, chase learning” — reuse for teacher capacity-building framing.
  • PM is the new bottleneck — useful for talking with researchers about why prototype-and-ship cycles need rethinking.

Health Coach Bot / agent work

  • Agent GPA framework (IMG_9335) is directly applicable — map our Health Coach Bot evals to the 9 metrics: answer correctness/relevance/groundedness, logical consistency, execution efficiency, plan quality, tool selection, plan adherence, tool calling.
  • Harness Engineering > Prompt Engineering (Mike Chambers, IMG_9362–9367) — most of our reliability work is harness work, not prompt work. Frame our infra investment that way.
  • “What we deliberately did not build” (IMG_9349) — adopt this anti-features pattern in our project briefs. Forces clarity on scope.
  • “Cited or it didn’t happen” (IMG_9346) — exact frame for the provenance-link work on Health Coach Bot.
  • Evals are broken, use them anyway — practical mindset, matches where we are with bot iteration.

Tools / Resources to Track

  • CopilotKit / AG-UI — possible substrate for Build-a-Bot v2; the Gen UI taxonomy (Controlled/Declarative/Open-Ended) is a useful product-design lens.
  • Snowflake Cortex Agent GPA evaluation tooling + TruLens (https://github.com/truera/trulens) — try on Health Coach Bot.
  • Reducto — for unstructured data ingestion if we go heavier on PDFs/docs.
  • Antigravity (Google DeepMind agent-first IDE) — watch.
  • OnMemory.ai / Harmony8 — deterministic memory; over-engineered for our use cases but interesting.

Connections to make

  • Brandon Middleton (d.school, AI literacy) — coffee. Action item filed.

Links / Resources Index

  • Conference site: https://ai-dev.deeplearning.ai/
  • Andrew Ng’s codream.ai (preview)
  • Gemma core docs: https://ai.google.dev/gemma/docs/core
  • AMD OpenClaw + vLLM: https://www.amd.com/en/developer/resources/technical-articles/2026/openclaw-with-vllm-running-for-free-on-amd-developer-cloud-.html
  • AMD OpenClaw notebook: https://github.com/Mahdi-CV/amd-gpu-workshops/blob/main/notebooks/open-claw/workshop.ipynb
  • AMD Developer Program: https://www.amd.com/en/developer-program.html
  • AG-UI / CopilotKit: https://docs.ag-ui.com/introduction
  • Mike Chambers on the agentic framework landscape: https://blog.mikegchambers.com/posts/agentic-framework-landscape/
  • Snowflake Cortex Agent Evals: https://bit.ly/cortex-agent-evals
  • Agent GPA framework: https://bit.ly/agent-gpa
  • Agent GPA notebook: https://bit.ly/agent-gpa-notebook
  • TruLens: https://github.com/truera/trulens
  • DeepLearning.AI Agent GPA course: https://bit.ly/deeplearning-agent-gpa
  • Actian VectorAI DB: https://docs.vectoradb.actian.com
  • Brandon Middleton (d.school): https://dschool.stanford.edu/directory/brandon-middleton
  • Carta startup data: carta.com/data

Appendix — Slide Photo Index

All photos at reference/dev-day-26-slides/ (61 WebPs, ~24MB total).

Day 1 morning (Andrew Ng / keynote panel):

  • IMG_9314 — “How Frequent?” 2×2 matrix (Everybody/Slop/Experts/Nobody)
  • IMG_9323 — “How much code should we write with AI?”
  • IMG_9324 — “The Product Management Bottleneck”
  • IMG_9325, IMG_9326 — “The AI engineer” (3 pillars: Coding Agents · Building Blocks · PM)
  • IMG_9327 — “AI native teams”
  • IMG_9328 — Summary + codream.ai
  • IMG_9368 — “Code is easy. Clarity is not.” (3 pillars: domain · execute · communicate)

Day 1 / AMD — Building Personal AI Agents (Eda Zhou, Mahdi Ghodsi):

  • IMG_9307, IMG_9308, IMG_9309 — K-Shaped Future of SWE (user-circled: Judgment & taste, Problem framing)
  • IMG_9310 — “Speed Is The Moat”
  • IMG_9311 — GEAK GPU kernel optimization
  • IMG_9313 — IREE Tokenizer (world’s fastest)
  • IMG_9329 — Session intro
  • IMG_9330 — Workshop pre-req (AMD Developer Program QR)
  • IMG_9331 — LLM → Chatbot → Agent
  • IMG_9332 — Three Components of an Agent (Model · Runtime · Tools)

Day 1 / Snowflake — Optimize Your Agent’s GPA (Anupam Datta):

  • IMG_9334 — Cortex Code platform overview
  • IMG_9335 — Agent GPA Venn diagram (9 eval metrics)
  • IMG_9336 — arXiv paper screenshot
  • IMG_9337 — Hands-on resources (bit.ly links)
  • IMG_9338, IMG_9339 — Free trial + Get Started guide QRs
  • IMG_9340 — Context Engineering definition
  • IMG_9341, IMG_9342 — Memory Engineering definition

Day 1 / Paige Bailey — What’s New (Google DeepMind):

  • IMG_9320 — Day 2 schedule screenshot (Paige Bailey circled; helps fix the day)
  • IMG_9321 — Google for Startups credits

Day 2 / Closing the Care Gap — VectorAI DB (William Imoh, Charlie Wood):

  • IMG_9316 — Topology Is a First-Class Design Decision (Cloud/On-Prem/Edge)
  • IMG_9317 — Hybrid Tier Architecture
  • IMG_9318 — Where the Vector Database Layer Is Heading (4 quadrants)
  • IMG_9319 — Get Started (community edition + enterprise guide QRs)
  • IMG_9343, IMG_9344, IMG_9345 — Agent Harness and MemOps (3 angles)
  • IMG_9346 — “What this actually is, in your terms” (4 constraints)
  • IMG_9347 — Actian VectorAI DB product overview
  • IMG_9348 — Three architectural forcing functions (Locality/Latency/Hybrid queries)
  • IMG_9349 — “What we deliberately did not build”
  • IMG_9352 — Six things to take home
  • IMG_9353 — “docker run it tonight” (Community Edition)

Day 2 / Mike Chambers — The Loop Was Never the Hard Part (AWS Bedrock):

  • IMG_9362 — “Build AI agents you can actually steer”
  • IMG_9363 — Recap: LLM = Prompt Eng, Agent = Context Eng
  • IMG_9364 — Harness 6-cell grid
  • IMG_9365 — Harness with annotations (system prompt → Loop, skills → Tools)
  • IMG_9366 — Recap (again): + Harness Engineering
  • IMG_9367 — Full architecture (Client / Runtime / Environment / Bedrock)

Day 2 / CopilotKit — AG-UI / Generative UI:

  • IMG_9369 — Windows & Mac Era of AI (CLI vs. AI interface)
  • IMG_9370 — The Agentic Frontend Stack
  • IMG_9371 — How AG-UI Works
  • IMG_9372 — Controlled Gen UI
  • IMG_9373 — Declarative Gen UI
  • IMG_9374 — Open Gen UI
  • IMG_9375 — The Generative UI Long Tail (taxonomy)
  • IMG_9376 — Course waitlist QR

Misc:

  • IMG_9354 — “Bootstrapped solo founder era is now” (Carta data)
  • IMG_9355 — Hotel/Airbnb info, accidental
  • IMG_9350 - 01 — iOS Vehicle Motion Cues settings, accidental
  • IMG_9351 - 01 — Day 2 Stage 2 schedule screenshot (Reducto session)
  • IMG_9377 - 01 — Day 2 Stage 3 schedule (Deterministic Memory · Vectara)
Source: reference/dev-day-26-conference-notes.md