GraphQLConf 2026

How do you make one of the world's largest federated graphs accessible to token-constrained LLM minions?

With hundreds of teams contributing to or consuming GraphQL APIs at Netflix, good tools are critical. Today, our GraphQL platform supports engineers across the entire dev lifecycle. However, the nature of developer tooling is rapidly changing.

It’s no longer enough to have a pretty UI if LLMs can’t access it—”agent-friendly” is now table stakes.

In this talk, we'll discuss how our tools have adapted to expose agent-friendly interfaces, allowing agents to seamlessly interact with and utilize them for exploring the graph, building queries, designing schemas, and more.

Finally, how can we leverage the power of AI within the tools themselves? We’ll discuss techniques for superpowering GraphQL tooling via focussed agents with guardrails and feedback loops, increasing accuracy and trust.

How do you expose all the internal tools to the Agents is the question everyone is asking today. Turns out we already expose all the things people can do with our internal tools at Meta through GraphQL and LLM Agents are now able to write GraphQL queries, so... come to this talk to see how both work wonderfully together!

How do you teach AI to navigate GraphQL schemas with thousands of fields? At Meta, we built an AI system that dynamically discovers and loads subschemas on-demand, enabling natural language interactions with complex enterprise APIs.

This talk shares hard-won lessons from building production AI that performs real-time schema exploration, manages dynamic subschema composition, and generates sophisticated GraphQL operations at Meta's scale.

Key Topics:
- Dynamic schema discovery from user intent
- On-demand subschema loading architecture (@require_graphql_subschemas directive)
- Teaching LLMs GraphQL type relationships and dependencies
- Performance optimizations for real-time schema introspection
- What failed and why certain approaches don't scale

Lessons from Production:
- Schema design principles that work better with AI
Security considerations for AI-driven schema access
- Operational challenges and monitoring strategies
- Attendees leave with battle-tested patterns for conversational GraphQL systems, specific techniques for dynamic schema loading, and honest insights about what didn't work along the way.

AI coding agents are now a daily reality for GraphQL developers, yet there's a persistent gap between what agents can do and what they actually know. Without guidance, they generate anonymous queries, skip variables, rely on deprecated patterns, and miss conventions experienced teams consider obvious. Every conversation starts from zero. Agent Skills are an emerging answer: a lightweight, open format for encoding expertise that agents can automatically apply. In a short time, the community has begun building Skills that teach everything from schema usage to client caching, and the ecosystem is evolving fast. This talk surveys the current state of GraphQL Agent Skills: what they are, how they're authored, how they plug into AI tools and workflows, and how they complement MCP. As the creator and maintainer of Apollo Skills, I'll share what we've learned building and shipping them. Through real-world examples, we'll see how Skills help agents design a schema safely, write the right operations, and recover from mistakes. We'll examine design trade-offs, emerging patterns, and open challenges still ahead. You'll leave knowing how to make your graph work better with AI agents.

Coding agents are reshaping how we build software. Implementing features, refactoring systems, and shipping changes at a pace unthinkable 6 months ago. But to be successful with agents you need the right feedback loop. One that guides your agent to success, not into the spiral of death.

Ask Claude to add a review system to your product API. Without knowing what's in use, it might reshape your types, move fields, and break your deployed clients because it is missing a crucial feedback loop of what's in use in your clients.

GraphQL changes this. Every client operation explicitly declares the exact fields and types it needs. That gives you something rare: field-level usage data across your entire consumer base. Not endpoint hits, but actual demand, broken down to the individual field.

When coding agents can access this data, they stop guessing. Evolve your schema grounded in reality, not assumptions.

This talk shows how GraphQL's inherent usage visibility and the rise of coding agents create a feedback loop that didn't exist before. And why it matters for anyone building APIs that need to evolve fast.

GraphQL offers a popular way for developers to access and interact with data. However, integrating GraphQL with enterprise databases often requires custom middleware, complex resolvers, and maintenance overhead. With Oracle AI Database 26ai, this changes: developers can now use GraphQL queries natively in the database, leveraging automated schema inference and built-in parsing with no loss of performance or scalability.

In this session, we will demonstrate Oracle’s first-class GraphQL integration, including the new table function that lets you run GraphQL queries as native SQL. We will showcase:

- How to map and query relational data with GraphQL, with built-in features for joins, predicates, ordering, & calculations.
- How LLMs can generate valid GraphQL queries from natural language, making API access approachable, and why targeting GraphQL via LLMs often delivers safer, better experiences than translating NL to SQL.

Whether you’re an architect modernizing data APIs or a developer working with complex schemas, this session will help you take advantage of the best of both relational databases and the GraphQL ecosystem, with added automation from today’s AI advancements.

Every developer has the same instinct when working with AI: take over. Copy the output, fix it by hand, wonder why AI ""doesn't really work."" That instinct is the problem.

When AI-generated code is wrong, the fix isn't editing the code — it's improving the instructions that produced it. This talk teaches that discipline using Agent Skills — open-format markdown workflows — and the GraphQL SDLC as working context. We'll build skills for schema design, resolvers, testing, and docs, developing intuition for when to refine instructions versus when you've hit a model limitation.

You'll leave with transferable techniques, open-source GraphQL skills, and the beginnings of your own agentic intuition.

As teams adopt the Model Context Protocol (MCP), they often run into a new problem: tool sprawl. Every backend API turns into its own MCP server, each with separate schemas, auth, versioning, and deployment concerns. What starts as a clean integration quickly becomes hard to manage. In this talk, I'll show how GraphQL can act as a unifying layer for MCP using GraphQL capabilities like schema introspection and persisted documents. By exposing multiple backend services through a single GraphQL API and connecting it via one MCP server, LLMs gain access to a rich, strongly typed interface without an explosion of tools. We’ll walk through a practical architecture and share patterns for keeping MCP systems scalable, discoverable, and governable beyond early experiments.

GraphQL isn't just an API technology—it's the perfect foundation for AI agents and LLM-powered applications. At Starbucks, we built GraphQL platforms at massive scale (180M+ queries/day, 10,000 stores, 31M+ app users) before GenAI became mainstream. Now, as we explore AI integration, we're discovering that GraphQL provides fundamental advantages for AI that are impossible with REST.

This talk explores the AI systems we're building on our existing GraphQL infrastructure:

In-store AI assistant (planned for Order Engine GraphQL BFF)
Mobile/web AI platform (exploring on Apollo Supergraph)
On-call automation using Model Context Protocol (MCP) servers
You'll learn how GraphQL reduces AI token costs by 75x, enables zero-configuration AI tool discovery, provides built-in guardrails through type systems, and why federation is the perfect architecture for enterprise AI agents. Real demos, proven patterns, lessons from building GraphQL at scale.

GraphQL's rich type system makes it an ideal foundation for agents to explore and work with APIs.
The SDL provides the structure agents need to reason about capabilities and data.
Queries let them retrieve information, while mutations enable them to take action.

In practice, however, production GraphQL schemas are often too large to fit in the context window and difficult to understand without additional context.
So what if agents could interact with any GraphQL API in a generic, reliable way?
In this session, we'll look at the challenges of agentic interactions with GraphQL and how semantic introspection could unlock a new way for agents to navigate the schema and interact with GraphQL APIs more reliably.

What if your GraphQL API could understand what developers need and generate valid operations from plain English? This talk introduces graphql-embedding, an open-source toolkit that parses GraphQL schemas into vector embeddings, stores them in a vector store, and uses a multi-agent LLM pipeline to generate validated GraphQL operations from natural language input.

The architecture is fully modular: swap vector stores between PGLite for local development and PostgreSQL for production, choose from Ollama, OpenAI, or Anthropic as LLM providers, and extend with your own. A key design decision was bundling a lightweight embedding model directly in the package, enabling local CPU inference with no external API calls, cloud dependencies, or GPU required. The entire pipeline to generate a operation works with small, efficient models like QWen 2.5 running locally via Ollama.

Everything ships as a VS Code extension called GraphQL Workbench, putting schema embedding and natural language operation generation directly in the developer's workflow. All packages, models, and the extension are fully open source under the MIT license.

GraphQL and Federation solve real problems: replacing hand-written orchestration with a declarative, typed contract between clients and backends. That model works. But the landscape is shifting — AI agents are becoming first-class API clients, and they need to compose across services, reshape responses, and build workflows faster than coordinated schema design allows.

The core insight: one graph doesn't have to mean one API. What if the supergraph were less a single schema and more a catalog of data and services? That shift opens up a different kind of client language: one with expressions, data restructuring, and the ability to call non-GraphQL APIs directly.

I'll show the result of our explorations: a language that keeps what makes GraphQL powerful — strong typing, composability, field-level selection — and extends it with the primitives clients need to work across service boundaries. It should feel familiar and is designed for any client — web, mobile, and AI agents alike. I'll explain what we learned from pushing GraphQL and Federation to their limits, and make the case that breaking the mold doesn't mean starting over.

When we give AI agents access to our GraphQL APIs, we introduce a new class of distributed system challenges: non-deterministic queries, potential N+1 floods, and authorization bypasses. How do we ensure our "AI-generated" queries are safe and efficient?

This talk bridges the gap between AI Quality Engineering and GraphQL governance. Building on my work designing evaluation frameworks for multi-agent systems, I will present strategies for monitoring and governing agents that interact with GraphQL endpoints. We will discuss how to implement "Semantic Rate Limiting" (analyzing query complexity vs. user intent) and how to evaluate the accuracy of agent-generated GraphQL syntax using "LLM-as-a-Judge" frameworks.

We will also cover the "Human-in-the-Loop" aspect: using GraphQL subscriptions to stream agent reasoning to human supervisors for real-time validation before a mutation is executed. Attendees will learn how to open their Graphs to AI without compromising on security or performance reliability.

Producing valid and realistic mock data for prototyping and testing has been an unsolved challenge for years. Mock data is tedious to write and maintain, but attempts to improve the process such as random value generation and field stubbing fall short as they lack essential domain context to make test data realistic and meaningful.
In this talk, I’ll share how we’ve reimagined GraphQL mocking at Airbnb by combining existing GraphQL infrastructure, rich product and schema context, and LLMs to generate convincing, type-safe mock data simply by adding a directive (@generateMock) to a field or operation:
- How integrating LLMs that are highly contextualized by a schema, documentation, and UX design into existing GraphQL tools drives a leap forward in the speed and quality of mock data creation.
- How a directive-driven approach lets engineers generate production-like, schema-conformant mock data without writing code.
- How integrating generated mock data into the GraphQL client runtime can enable engineers to build and test clients before server implementation.
- How this strategy guarantees that generated mock data is correct, deterministic, and stays in-sync with the server schema.