▶ Watch ↗AI Engineer World's Fair 20251:44:51
Conference affiliation: Google DeepMind · 2026
Philipp Schmid is a Staff Engineer at Google DeepMind working on Gemini, agents, and the Gemini API. At Hugging Face, he helped developers train and deploy open models through managed infrastructure. His work at Google DeepMind extends that practical focus to agent interfaces and execution environments, alongside a pointed engineering recommendation: as models improve, test which orchestration code and instructions developers can remove.
Based in Nuremberg, Germany, Philipp worked in analytics and big-data consulting at PRODATO and designed cloud-native machine-learning architectures for financial-services and insurance companies at CodeCamp:N. He joined Hugging Face in December 2020 as a machine-learning engineer and became a technical lead in February 2022. His responsibilities expanded from the Amazon SageMaker integration to engineering partnerships with AWS, Google Cloud, Azure, and Cloudflare.
His 2021 SageMaker integration guide explained how prepared Hugging Face containers and an SDK extension connected developers’ training scripts to managed compute. He also helped create Hugging Face Inference Endpoints, providing a route from a model on the Hub to a hosted service.
Philipp’s technical writing explained the machinery behind deployment. His 2023 inference-container guide demonstrated serving an open conversational model through Text Generation Inference on SageMaker: tensor parallelism distributed the model across GPUs, continuous batching increased throughput, and streaming returned text as it was generated. In 2024, Philipp and Jeff Boudier coauthored an introduction to Inferentia2 support, explaining how AWS accelerators became available through SageMaker and Hugging Face Inference Endpoints. His contributions to these collaborative products included partnership engineering and tutorials that helped developers adopt them.
His deep-learning-pytorch-huggingface repository develops the same practical approach through examples of instruction tuning, preference optimization, quantization, distributed training, and inference. Together, these examples explain how developers can adapt and operate a model after selecting it.
Philipp joined Google DeepMind in February 2025 as a senior AI developer-relations engineer and became a staff engineer that October. His work spans Gemini and Gemma across cloud and on-device platforms. His gemini-samples repository continues his teaching through working examples of function calling, memory, document processing, multimodal generation, and agent integrations.
Philipp’s comparison of three GitHub pull-request reviewers makes his argument for simpler agent infrastructure concrete. A handwritten Python implementation manages the tool loop, JSON schemas, function routing, and conversation state. A framework handles much of that machinery, but developers still write the individual tools. A hosted agent can instead use a shell, the GitHub CLI, and instructions stored in files.
The difference becomes consequential when the reviewer needs another capability. Adding security scanning to the earlier implementations requires a tool implementation and its integration into the agent. With the hosted version, a developer can supply a scanner and a skill explaining when and how to use it. The model composes those general tools; developers remain responsible for domain instructions, access restrictions, and evaluations of the result. Philipp argues that a harness becoming more complicated with every model improvement is a reason to reconsider its design.
He treats the filesystem as an agent workspace, holding instructions, skills, intermediate results, and handoffs. His sandbox examples explain how environments can persist across interactions, let agents share context through files, and become prepared starting points for reusable agents. He also distinguishes a shared harness from an identical agent: the Antigravity product and its remote API agent can share underlying execution machinery while using different tools and system instructions.
His portfolio-auditing demonstration, Bug, connects that environment to recurring work. A playbook names a Python audit script and explains how to interpret and record its results. A cron trigger can start the audit, and a Google Workspace MCP connection lets the agent update a Google Sheet. The schedule determines when work begins; approval hooks can separately require human review before particular actions. Developers can also retain selected operations in their own application, executing a requested function outside the sandbox and returning its result.
Credential handling is another concrete part of this design. Philipp describes an outbound proxy that injects credentials into requests to configured domains, keeping raw tokens outside sandboxed code. This separates the agent’s ability to make an authorized request from possession of the underlying secret.
His support for MCP follows a related concern about duplicated integration work. In his Gemini 2.5 workshop, Philipp explains that MCP supplies reusable tool definitions and implementations; the model still selects tools through function calling. Teams can share an integration instead of each writing the same API wrapper. He favors first-party servers because service owners understand their own authentication and permission systems.
Handing more execution to a model changes what Philipp asks developers to preserve and test:
delete item function does not inherit the product knowledge that tells an experienced developer what its identifier means or how the operation can fail.Philipp distinguishes temporary capability skills, which compensate for something a model cannot yet do consistently, from longer-lived preference skills encoding a team’s practices. Both require evaluation, but better models can make a capability skill unnecessary.
In Don't Ship Skills Without Evals, he describes his team’s 117-case evaluation of Gemini Interactions API guidance across Python and TypeScript. The API had arrived after the model’s training, so the skill supplied information the model needed to generate current code. Inexpensive validators checked SDKs, model names, methods, and obsolete patterns. Negative cases tested whether the skill activated when it should remain unused.
Philipp draws a useful distinction between an engineer using a coding agent and a customer using an agent inside an application. The engineer may notice that a skill failed to load and explicitly invoke it. The customer may know nothing about skills. Triggering descriptions therefore need to work with the requests customers actually make, including vague ones.
He recommends precise triggering directives and references loaded only when needed. Descriptions consume context on every invocation; an oversized skill adds further cost when loaded. For an unchanging sequence of operations, he recommends a script the agent can run rather than instructions that make the model reconstruct the workflow each time.
With-and-without-skill ablation tests determine whether the extra instructions improve results. Philipp recommends retiring a skill when the model performs equally well without it, while keeping the evaluation to detect later regressions. Removing the instructions need not mean losing the test that established why they were useful.
▶ Watch ↗AI Engineer World's Fair 20251:44:51
▶ Watch ↗AI Engineer Europe 202610:40
▶ Watch ↗18:27
Loading more talks and highlights…