Operational roles
Three practitioner roles — the Agent Champion, the Documentation Architect for Agent Consumption, and the API Experience Designer. Named, scoped, and measured.
In the traditional DevRel model, value was created through production: writing tutorials, giving talks, building demos, running events. The skill was in execution. Agentic Relations changes where value concentrates. As AI tools accelerate the production of content, the binding constraint shifts from production to judgment. The judgment is where value now accumulates.
This is Amdahl's Law applied to DevRel work itself. Scarcity migrates upstream: from execution to review, from review to evaluation of approaches, from evaluation to framing problems, from framing to encoded institutional standards that everything else gets evaluated against.
The three new roles Agentic Relations requires each operate primarily at this upstream layer.
Also: Agent Liaison · AI Integration Steward
Maintains the agent-consumable infrastructure that determines whether AI coding tools produce correct integrations with the platform. Monitors FAISR. Owns the recipe library. Files the feedback that makes the platform structurally more agent-friendly.
Also: AI Documentation Strategist
Optimizes documentation for machine retrieval and semantic precision rather than human navigation. Thinks in chunking strategy, RAG accuracy, and agent query patterns rather than reader journey and progressive disclosure.
Also: Agent-Native API Strategist
Audits the platform's API surface for agent-parseability. Makes the case for agent-native investment. Influences error model design, auth flow simplicity, rate limit calibration, and the availability of machine-readable schemas.
Role 01
The Agent Champion maintains the agent-consumable infrastructure that determines whether AI coding tools produce correct integrations with the platform — monitoring success rates, maintaining the recipe library, and feeding failures back to the platform engineering team.
Monitoring (continuous). The Agent Champion runs a structured test suite weekly — directing multiple AI coding tools at common integration tasks and scoring the output against a rubric. Did the agent authenticate correctly? Did it use current API endpoints? Did it handle the primary error states? Did it over-engineer? This produces a FAISR score, tracked as a time series, broken down by tool and by task.
Maintenance (triggered). When a new API version ships, the Agent Champion audits all published recipes for breakage and updates them before the old version is deprecated. When monitoring surfaces a recurring failure, they produce a corrective recipe and identify the doc gap that caused it.
Feedback (systematic). Recurring agent failures are symptoms. Behind each is either a documentation ambiguity, an API surface complexity, or a missing machine-readable schema. The Agent Champion translates symptoms into specific, actionable improvement requests for the platform engineering team — each quantified against the Amdahl ceiling.
The Agent Champion's primary artifact is the recipe library: a versioned collection of validated prompt recipes, MCP server definitions, and structured integration examples. It is not documentation in the traditional sense — it is designed for agent retrieval, not human navigation. Semantically precise, answer-first, with explicit error taxonomy.
Strategically, the recipe library is the platform's encoded institutional taste. The accumulated judgment of every integration failure, architectural decision, and edge case — made accessible to every AI tool a developer might use. It compounds rather than depreciates. It does not depend on any individual's continued employment.
Deep platform expertise (non-negotiable) + systematic engineering rigor + data analysis for error log interpretation + enough understanding of AI tool behavior to diagnose prompt engineering failures. This combination is currently rare. It describes the 20% of Developer Advocates who already do this work informally and call it "AI tool testing."
Role 02
Optimizes documentation for machine retrieval and semantic precision rather than human navigation — the technical writer equivalent who thinks in chunking strategy, RAG accuracy, and agent query patterns.
Traditional technical writing optimizes for the human reader: narrative flow, progressive disclosure, assumed prior knowledge, clear headings that support skimming. A skilled technical writer produces documentation a human can navigate efficiently.
The Documentation Architect for agent consumption optimizes for a fundamentally different consumer. AI tools retrieve specific sections as context for generation tasks. They don't read progressively. Documentation that is beautifully structured for humans can produce catastrophically bad agent context if:
The Documentation Architect audits documentation against a set of common agent queries, identifies which pages produce the highest rate of agent errors when used as context, and redesigns those pages for dual-audience consumption.
Technical writing experience + understanding of how RAG systems chunk and embed content + ability to think about documentation as a retrieval corpus rather than a narrative + willingness to instrument and measure documentation performance against agent query accuracy.
Role 03
Audits the platform's API surface for agent-parseability and makes the case for agent-native investment — influencing error model design, auth flow simplicity, rate limit calibration, and the availability of machine-readable schemas.
Most APIs are designed for human developers. Error messages are written to be readable. Auth flows are designed for session-based human login. Rate limits are set at levels that prevent abuse by human-speed calling. Response structures are optimized for human comprehension over machine parsing.
AI agents interact with all of this at a fundamentally different speed and with a fundamentally different tolerance for ambiguity. "Invalid token — please re-authenticate" may be semantically opaque to an agent that needs to map the error to a specific remediation path. Rate limits calibrated for human-speed calling trigger constantly when an AI agent is making rapid sequential calls.
The API Experience Designer sits at the intersection of DevRel and platform engineering. They audit the API surface from the agent's perspective, quantify the Amdahl tax imposed by each human-speed design decision, and make the engineering case for agent-native redesign — backed by adoption data and competitive benchmarking.
Platform engineering credibility + DevRel orientation + deep understanding of AI agent behavior + ability to translate adoption data into engineering investment arguments. The rarest combination of the three new roles.
The three roles form a feedback loop. The Agent Champion's monitoring surfaces integration failures. The Documentation Architect addresses failures caused by documentation quality. The API Experience Designer addresses failures caused by API surface design. The Agent Champion's metrics validate that the fixes worked.
The loop runs weekly for monitoring and maintenance. It runs on a release cadence for API changes. It informs a quarterly product roadmap review for structural investment decisions.
| Organization | Minimum viable | Full program |
|---|---|---|
| Small (1–5 DevRel) | One practitioner owns Agent Champion function one day per week. Manual test suite of 10 tasks. Recipes in docs. | Grow suite and recipe library. Hire dedicated Agent Champion at 20% AI-tool adoption threshold. |
| Mid-size (6–15) | Dedicated Agent Champion, full-time. Automated test suite across 5 AI tools. Versioned recipe library. | Add Documentation Architect. Agentic Hackathon program. Full four-layer dashboard. |
| Large (15+) | Two-track structure: Human Relations + Agent Relations, shared leadership. FAISR and Amdahl ceiling as primary metrics. | API Experience Designer role. Agent-native MCP server. Competitive benchmarking. Recipe library as published community resource. |