Small open models are becoming capable enough to run agentic and multimodal tasks on phones, laptops, and other local devices.
2
Coding agents need progressive discovery, programmatic tool calling, and a mix of skills, MCP, CLIs, and computer use rather than one universal integration method.
3
Faster agents make human judgment more important because they can generate technical debt, review backlogs, and unverified changes at much higher speed.
Summary
This compilation covers the second day of AI Engineer Europe, with talks about local models, agent protocols, coding-agent design, evaluation, and product engineering. Omar Sanseviero presents Gemma 4, including small models for phones and Raspberry Pi, the E2B architecture, multimodal input, and Apache 2 licensing. David Soria Parra explains why MCP needs progressive discovery and programmatic tool calling, alongside skills and CLIs. Mario Zechner and Armin Ronacher argue for minimal, legible codebases and deliberate friction because agents accumulate complexity without human review. Other talks show agents writing CUDA kernels, running long missions, evaluating AI systems, and working across mobile and cloud environments. The closing discussions move from implementation speed to product quality, durable UI artifacts, model limitations, and using agents for conference operations and other non-coding work.
Small open models can run useful agentic work on local devices
Omar Sanseviero describes Gemma 4 as a family ranging from 2 billion to 32 billion parameters. The smallest models can run on Android, iPhone, and Raspberry Pi, with multimodal understanding, reasoning, and on-device agentic tasks. He shows examples of Gemma coding in airplane mode, generating SVGs through ten parallel instances on a laptop, and helping with Android development. The E2B architecture keeps only about two billion effective parameters in GPU memory while placing per-layer embeddings in CPU memory or on disk. Sanseviero also points to Apache 2 licensing, support for more than 140 languages, and the ability to fine-tune models for specialized use cases.
Agents need a connectivity stack rather than one integration protocol
David Soria Parra says MCP has grown from a local, tools-only specification into a protocol with remote capabilities, authorization, tasks, elicitation, and MCP applications. He argues that agents in 2026 will combine skills, MCP, CLIs, and computer use. Skills carry domain knowledge in simple files. CLIs work well in local sandboxes and for tools already present in pretraining. MCP adds rich semantics, UI, long-running tasks, authorization, governance, and platform independence. He recommends progressive discovery, where tools load only when needed, and programmatic tool calling, where a model writes code to compose several tool calls inside an execution environment.
Minimal agent harnesses give developers control over context and extensions
Mario Zechner explains why he built Pi after becoming frustrated with changing system prompts, hidden context modifications, limited model choice, weak observability, and shallow hooks in larger coding agents. Pi has a small core, four built-in tools, and an extensibility model based on TypeScript modules. Users can add tools, slash commands, event handlers, custom providers, custom compaction, and session state. Zechner says the agent can modify itself when given documentation and examples for writing extensions. He also warns that agents produce compounding errors, duplicated abstractions, and delayed technical debt. His advice is to scope tasks, use agents for non-critical or easily evaluated work, read critical code line by line, and keep the friction that builds understanding.
Agent-legible codebases need mechanical constraints and deliberate review points
Armin Ronacher and Cristina Poncela Cubeiro describe the pressure created when agents make code quickly but humans cannot review at the same rate. They distinguish libraries, which often have a clear core and tight constraints, from products, where UI, permissions, billing, APIs, and feature flags interact in ways that exceed an agent's local context. Their practices include modular components, clearly defined code-flow steps, one SQL interface, one UI component library, no bare catch blocks, no dynamic imports, and unique function names. They use a Pi extension to separate mechanical problems from human judgment calls. Database migrations and permission changes require human decisions. They argue that friction helps engineers steer systems and retain understanding.
Fast models make validation and continuous cleanup affordable
Sarah Chieng presents Codex Spark as a model that generates 1,200 tokens per second, compared with roughly 40 to 60 tokens per second for the Sonnet and Opus families. Her concern is that old habits, such as huge prompts, large commits, and many unattended agents, will produce bad code much faster. She recommends using slower models for planning and faster models for execution, turning successful sessions into repeatable skills, and adding tests, linting, pre-commit hooks, diff reviews, browser QA, and refactoring after each step. Fast models also make it practical to generate many design or architecture alternatives and choose among them. She suggests externalizing state with agents.md, plan.md, progress.md, and verify.md so new sessions can resume with bounded context.
Long-running missions require separate planning, implementation, and validation roles
Luke Alvoeiro describes Factory missions as ecosystems of agents that communicate through structured handoffs and shared state. An orchestrator clarifies requirements, creates milestones, and writes a validation contract before implementation. Workers implement features with clean context, while validators run tests, type checks, linting, code review, and live application testing. The user-testing validator interacts with the application through computer use and checks complete flows. Workers write handoff summaries that record completed work, remaining issues, commands, and exit codes. Factory runs features serially to avoid conflicts, while parallelizing read-only research and review. Alvoeiro says the longest mission ran for 16 days and that most of its wall-clock time was spent on validation.
AI systems can be evaluated by turning traces and datasets into agent-readable files
Lawrence Jones explains how Incident.io uses AI to evaluate and debug its production investigations. Evals work like AI unit tests: they provide input, run a prompt, and apply grading criteria to the output. The team built a CLI so coding agents can inspect, add, edit, and run eval cases without loading huge YAML files into context. They also export complex AI interactions, prompts, tools, and traces into a filesystem that an agent can inspect alongside the application code. For larger backtests, they use parallel agents to analyze individual investigations, then cluster failures into cohorts and produce a report. Jones recommends storing intermediate analysis in files, combining it with the codebase, and writing repeatable markdown runbooks for complex investigations.
Product quality and human judgment remain separate from code-generation speed
In the Linear fireside chat, Tuomas Artman says the company still groups customer requests around their underlying problems instead of shipping every request directly. Linear uses Quality Wednesdays, when engineers find and fix small product problems, and a Zero Bug Policy, where reported bugs are assigned immediately and become the highest priority. Artman says agents can fix many routine bugs, but they do not have taste or a sense of how an interaction feels over time. Jacob Lauritzen makes a related case for durable UI artifacts in complex vertical AI work. Documents, tables, comments, and review surfaces give people more control than a long chat transcript and let agents handle bounded parts of a larger workflow.
"The bottleneck in software engineering nowadays is not intelligence. It's now limited by human attention."3:47:03
Who should watch
You are building coding agents or agent-enabled products and need to decide where skills, MCP, CLIs, and computer use fit.
Your team is generating code faster than it can review, and you need concrete ways to control context, validate behavior, and contain technical debt.
You are evaluating long-running or multi-agent workflows and want examples of handoffs, validation contracts, filesystem-based debugging, and durable UI review.
