AIE Europe Keynotes & Coding Agents ft. Pi, Google Deepmind, Anthropic, Cursor, Linear, & more

Summary of the Video’s Main Points (AI Engineer Europe: Keynotes & Agent Talks)

1) Day 2 kickoff: coding agents, MCP, and European AI momentum

• The MC (Tjisk Kumar) frames Day 2 around coding agents, MCP (Model Context Protocol), and broader infrastructure topics (AI architecture, media, GPUs).
• He emphasizes community participation (posting highlights with tags) and spotlights a theme that Europe is producing real AI innovation, including examples tied to Google DeepMind activity in Europe.

2) Google: Gemma 4 — more capable open on-device models + Apache 2 licensing

Presenter: Omar Santoro (Google DeepMind)

• Gemma 4 is positioned as Google’s most capable open model family yet, spanning roughly 2B to 32B parameters.
• Key claims:
  • Developer-friendly model sizes that can run on phones, desktops, and consumer GPUs.
  • An “effectively two billion parameters” style design (described via per-layer embeddings) aimed at very fast on-device inference by moving non-critical computation off-GPU (CPU/disk).
  • Support for multimodal tasks (images/video/audio, speech recognition/translation).
  • Strong multilingual coverage (trained across 140+ languages), aided by a tokenizer approach for multilingual fine-tuning.
  • Rapid community uptake: many downloads and numerous community fine-tunes/variants.
  • A major openness improvement: a license change to Apache 2, improving control and adoption.
• Mentioned “official variants”:
  • Shield Gemma (safety/production)
  • Medma (medical tasks)

3) Anthropic (MCP): why MCP matters for future agent connectivity + “progressive discovery”

Presenter: David Sora Par (Anthropic)

• MCP is described as connective tissue enabling agents to:
  • Ship UIs and tools via MCP servers (not only tool calls via a client SDK).
  • Run across environments like cloud systems, chat platforms, IDEs, and developer tooling.
• Adoption milestone: approximately 110M monthly downloads, attributed to the broader ecosystem (servers, clients, SDKs, frameworks).
• Core message: 2025 = coding agents; 2026 = production agents
  • Agents will need stronger enterprise connectivity to SaaS apps, drives, auth/governance, and shared semantics.
• Technical guidance:
  • Prefer progressive discovery (load tools only when needed) instead of dumping everything into the context window.
  • Use programmatic tool calling / code-mode patterns to reduce expensive “tool A → text → tool B” orchestration overhead.
  • Avoid “REST-to-MCP conversions” in favor of agent-native designs that use MCP semantics.
• Roadmap directions:
  • Improve MCP transport scalability (stateless transport proposals referenced).
  • Add better async primitives and SDK revisions (TypeScript/Python v2).
  • Enterprise features like cross-app access and server discovery.

4) Agent orchestration tooling: AgentCraft — visibility, autonomy, and multi-agent “missions”

Presenter: Ido Salman (AgentCraft / MCPUI / MCP apps)

• Central claim: scaling from 1 agent to many often fails because engineers become the bottleneck.
• AgentCraft approach borrows from RTS/game orchestration:
  • Visibility: map agent activity onto the user’s filesystem, including lineage/history of actions.
  • React fast: cycle quickly between agents that require approval/attention.
  • Campaigns: run agents in containerized contexts so humans move from babysitting to reviewing bundles.
  • Collaboration: humans and agents co-work via shared workspaces, including “soft collaboration” cues between agents.
• Goal: increase autonomy while keeping work reviewable and coordinated.

5) Pi / OpenRewrite-style critique: coding agents can damage OSS without discipline

Presenter: Mario Zechn (creator of Pi; engine inside OpenClaw)

• Strong criticism: agents can compound errors, break workflows, and degrade software quality if misused.
• He argues for:
  • Minimal cores and extensibility rather than heavyweight monolithic agent harnesses.
  • Better workflow control and observability.
  • Careful handling of “slop automation”: if agents generate code without reliable oversight, they may create brittle, unreviewable complexity.
• Emphasis: the market needs better evaluation of agent harnesses and safer operational practices.

6) “Friction is judgment”: Arendil + Flask (quality/safety via deliberate slowdown)

Presenters: Armen Ronacer (Flask founder) & Christina Ponella Cubro (Arendil / “native AI engineer”)

• Theme: teams chase “frictionless shipping,” but removing friction removes the judgment and reliability steering humans need.
• Organizational/psychological problems discussed:
  • Addictive fast output reduces reviewing capacity.
  • PR size and code complexity balloon.
  • Agents optimize for “progress” instead of long-term correctness, increasing entropy.
• Proposed remedy: agent-legible codebases
  • Modularize architecture and code flow.
  • Use mechanical enforcement (lint rules, constrained patterns, consistent primitives).
  • Separate “mechanical bugs” (agent can fix) from decisions requiring human judgment (e.g., migrations, permissions).
  • Add structured review cues to restore human attention where it matters.

7) “World Fair” expansion announcement

• Organizers announce scaling the event:
  • AI Engineer World Fair (San Francisco): June 29 – July 2
  • Location: Moscone West
  • Mentions sponsor tiers and registration/talk submission.

8) Fast coding models: “fast inference requires slow developers”

Presenter: Sarah Chang (Cerebras / discussion involving OpenAI’s “Codex Spark”)

• Core argument:
  • Coding models are moving toward much higher token generation speeds (e.g., ~1200 tokens/sec cited).
  • If developer workflows keep old habits (big one-shot prompts, many agent swarms, minimal verification), those habits generate faster slop.
• Practical playbook:
  • Use stronger models for planning, faster models for execution.
  • Make workflows verifiable earlier: tests, linting, pre-commit checks, diff review, and continuous validation.
  • “Cherry-picking”: generate many candidates quickly, then select the best output.
  • Treat the model like an on-tap programmer, not a background worker you only check later.
  • Externalize memory/context management with persistent files/checklists (e.g., agents.md, plan.md, progress.md, verify.md).

9) AI for debugging AI systems: Incident.io “AI SRE” with evals + downloadable UI files

Presenter: Lawrence Jones (Incident.io)

• Focus: agents used not only for building products, but for managing and debugging AI systems at scale (“AI SRE”).
• Challenges:
  • Complex investigations involve hundreds/thousands of prompts and telemetry queries.
  • Determining whether a generated report is “good” vs “wrong” is time-consuming, and manual review becomes impossible across many accounts.
• Solutions discussed:
  • Use evals as “AI unit tests” (prompt → criteria → pass/fail), while managing the complexity of eval datasets.
  • Provide agent-friendly tooling: an eval CLI/tool so agents can edit evals without context blowups.
  • Convert UI/debugging views into downloadable file systems runnable inside coding agent environments (e.g., Code/ClawCode), enabling agents to locate where to change prompts/tools.
  • Use analysis pipelines and failure clustering across backtests to find systemic causes.

10) Long-running “missions” for agents (multi-day, multi-agent systems)

Presenter: Luke (Factory / Goose prototype / missions framework discussion)

• Claim: the bottleneck is human attention, not model intelligence.
• Missions framework:
  • Structured multi-agent system with orchestrator + workers + validators.
  • Validators enforce end-to-end behavior, not just unit tests, via QA-style execution with real user behavior flows.
  • A validation contract defines correctness before coding begins.
  • Self-healing relies on structured handoffs (what ran, what failed, what remains).
  • Serial execution with targeted parallelization reduces conflict/drift.
  • “Mission control” provides async oversight and progress/budget visibility.
• Model placement matters:
  • slow reasoning for planning, fast execution for workers, and careful instruction adherence for validation.

11) Agent time management / “FOMO”: Command & Control for coding agents

Presenter: Michael Richmond (Bitly; “command and control”)

• Main idea: FOMO (fear of missing agent time) happens when tasks pause waiting for user input.
• Solution: a single UI to monitor, notify, and resume agent sessions:
  • subscribe to sessions for push notifications,
  • resume from mobile/web,
  • start new sessions remotely,
  • dashboards and session management.
• Architecture: agent platforms emit lifecycle events to a control plane; the UI aggregates across tools and machines.

12) VS Code + GitHub Copilot: “coding with agents” via local/background/cloud + MCP

Presenter: Liam Hapton (Microsoft / VS Code & GitHub Copilot)

• Describes agent types within the VS Code experience:
  • Local agents (hands-on coding/testing)
  • Background agents (automation while the developer stays involved)
  • Cloud agents (documentation and less interactive tasks)
• Emphasis: reduce cognitive load by making VS Code a single entry point:
  • MCP server access for tool workflows,
  • GitHub Actions isolation/safeguards,
  • customization via chat settings, custom agents, prompt files, and hooks/skills.
• Demo concept: three agents working simultaneously on a single ticket (e.g., background UI creation, local test writing, cloud docs).

13) Linear + shipping fast: “agents should improve bugs—but don’t lose taste/quality”

Presenters: Gerge Oros & Thomas Armman (CTO, Linear)

• Debate: rapid agent-driven shipping could reduce quality if teams say “yes” too easily.
• Linear perspective:
  • They don’t ship everything blindly; they cluster feedback and address root causes with strong UX emphasis.
  • Agents are used to auto-fix a subset of bugs with PRs focused on immediate reliability improvements.
• Quality management practices:
  • Quality Wednesdays: recurring effort to find and fix small issues.
  • Zero-bug policy: bugs are assigned immediately and fixed fast (or intentionally not fixed if extremely niche).
• Discussion: “quality” often requires organizational rituals and measurable proxies, since it’s hard to evaluate directly.

14) Lagora legal tech: complex vertical agents need more than chat (higher-bandwidth artifacts)

Presenter: Jacob Laurson (Lagora CTO)

• Argument: long-running agent tasks fail in plain chat:
  • agents lose context,
  • compaction errors,
  • drift.
• Framework:
  • Use AI where outputs are easily verifiable and decompose higher-uncertainty work.
  • Humans collaborate where trust/control matters via:
    • skills (encapsulate judgment),
    • elicitation (ask humans when uncertain),
    • high-control UX with durable interfaces (annotated documents, tabular review views), rather than linear chat threads.

15) Arena benchmarking: “models still suck at…” judgment reliability and nonsense reasoning

Presenter: Peter Gstiff (Arena.ai)

• Data-driven argument: benchmark charts that always “go up” can hide unresolved weaknesses.
• “Silly nonsense benchmark” approach:
  • Test whether models recognize nonsense prompts and refuse/push back rather than accepting.
  • Many models “accommodate” nonsense rather than clearly rejecting it.
• Second view:
  • user voting shows a dissatisfaction rate even between top models (improving over time, but not reaching zero).
• Notable finding: increasing “reasoning” settings doesn’t necessarily improve nonsense rejection—and may sometimes worsen outputs.

16) Final “agents everywhere” theme (conference organizers)

Presenter: Swix (co-founder, AI Engineer Conferences)

• Focus: agents expanding beyond coding into broader business operations:
  • workflow management, scheduling, data management, ETL-ish tasks, content/ops.
• Internal example: agents change how they run the conference pipeline, producing high output with a small team.
• Conclusion: “agents for everything else are coming”—adopt them broadly once workflows are in place.

---

Presenters / Contributors (Named in Subtitles)

• Tjisk Kumar (MC)
• Omar Santoro (Google DeepMind)
• David Sora Par (Anthropic)
• Ido Salman (AgentCraft / MCPUI)
• Mario Zechn (creator of Pi; OpenClaw)
• Armen Ronacer (Flask founder; Arendil)
• Christina Ponella Cubro (Arendil)
• Benjamin Duny (AI Engineer Conferences; co-founder/creative director)
• Swix (AI Engineer Conferences; co-founder)
• Gerge Oros (Linear participant — subtitle appears as “Gerge Oros”)
• Thomas Armman (Linear CTO)
• Jacob Laurson (Lagora CTO)
• Peter Gstiff (Arena.ai)
• Lawrence Jones (Incident.io)
• Luke (Factory; missions framework prototype)
• Michael Richmond (Bitly)
• Liam Hapton (Microsoft / VS Code & GitHub Copilot)
• Sarah Chang (Cerebras)
• Ben Burtonshaw (Hugging Face)
• Alex (host for coding agents track; “Thursday podcast” mentioned)
• Matias (speaker on Pi embedded in OpenClaw / product embedding)
• David Gomez (Cursor; “markdown as skills” talk)
• Alex (coding agents track host)