Design and Implement Robust API Solutions

The API Integration Specialist is an autonomous agent that designs, implements, and documents API solutions across REST and GraphQL. It works in six stages: first analyzing the existing codebase and database schemas with Read and Glob tools to identify data models, business logic, integration points, and auth requirements; then choosing the API paradigm (REST, GraphQL, or hybrid) and designing the resource hierarchy, data schemas, and versioning strategy; then producing OpenAPI/Swagger specifications for REST APIs and GraphQL schemas with resolvers and mutations, alongside an error-handling and rate-limiting plan; then designing authentication flows (OAuth2, JWT, API keys), authorization and permission models, input validation, and audit logging; then generating a developer portal with interactive documentation, multi-language code samples, SDK specifications, and sandbox environments; and finally building a full test suite covering unit tests, contract testing, load testing, and security scenarios.

Use this agent when you need a complete, production-ready API layer designed API-first - the specification is produced before implementation, and every deliverable (routes, auth middleware, docs, tests) follows from that spec. It is well suited to greenfield API design or to formalizing an undocumented existing API into OpenAPI/GraphQL schemas with a developer portal. It designs specifically for scalability (proper caching and pagination on list endpoints) and for errors that are actually debuggable - meaningful messages paired with correct HTTP status codes rather than a generic 500 for every failure. It is not meant for ad hoc single-endpoint scripting or for projects that don't need a documented, versioned contract - that scalability and error-handling discipline is more process than a quick internal script needs.

type Query {
  getUser(id: ID!): User
  getUsers(filter: UserFilter): [User]
}

type Mutation {
  createUser(input: CreateUserInput!): User
  updateUser(id: ID!, input: UpdateUserInput!): User
}

Given a codebase and its data models, the agent outputs an API Specification Document (OpenAPI 3.0.3 YAML with paths, parameters, and responses), a GraphQL schema with queries and mutations, complete implementation code (route handlers with error handling, database integration layers, authentication middleware, input validation), developer portal assets (interactive docs with live examples, SDK samples in Python/JavaScript/cURL, integration tutorials, Postman/Insomnia collections), and a testing suite (unit tests per endpoint, integration tests with database mocking, performance benchmarks, and security penetration-testing scenarios).

Backend and platform engineers who need to stand up or formalize an API surface with the full production checklist - versioning, auth, rate limiting, and developer-facing documentation included from the start rather than bolted on later. It suits teams that want a consistent contract-first workflow (OpenAPI/GraphQL spec drives implementation) and that expect every endpoint to ship with a clear, executable example rather than a bare parameter list, so a developer can copy a working request instead of reverse-engineering one from the spec.