Your AI agent harness is overengineered. The model got better.

The shift. Philipp Schmid from Google DeepMind demonstrated a clear evolution in how agents are built: from raw Python loops to framework abstractions, and now to a file-and-instruction model where markdown files replace most code. The demo built the same GitHub PR review agent three ways, each version deleting code and adding files.

The pattern. Version one required a Python class, JSON tool schemas, manual tool routing, error handling, and state management. Version two used the Agent Development Kit (ADK) which removed boilerplate but still required Python tool implementations. Version three used Google's remote agent with a sandbox environment, GitHub CLI, and a single agents.md file for instructions. The agent handled tool selection, installation, and error recovery autonomously.

The mechanism. Google's interactions API and remote agent provide server-side state management, automatic context compaction, and an isolated Linux sandbox with a network proxy for credential injection. Users define an agents.md file with instructions and skills.md files for capabilities. The agent self-discovers which tools to use rather than requiring predefined function calls.

The evidence. Schmid cited Cursor replacing 12,000 lines of TypeScript with 200 lines of agent files for git worktree orchestration. He mentioned Ancient Engineering Manos refactoring their agent harness five times in six months, LangChain rearchitecting open deep research three times in a year, and Worsel removing 80% of their tools for better performance. These examples suggest a pattern, not a controlled experiment.

The trade-off. Moving orchestration from code to files trades deterministic control for model autonomy. Teams lose the ability to audit exact execution paths and must trust the model's tool selection. The approach depends on model quality, raises governance questions about agent actions, and shifts the debugging challenge from code to prompt engineering. Missing from the talk: evaluation strategies, failure modes, and cost implications of longer agent sessions.

The bottom line. The trend is real: better models enable less orchestration code. But the practical path for most teams is incremental, not all-or-nothing. Start by moving one or two deterministic workflows to instruction files, measure success rates, and keep escape hatches in place. The hard work moves from code to evaluation.