2026-05-19 Agents WG

Raw Gemini-transcribed meeting notes and transcript available on Google Docs

Date: May 19, 2026 Attendees: Luca Chang, Vinay Ramesh, Madhavi PDB, Victor Lu

Discussion

Luca presented a document surveying existing agent use cases in publicly-available, production MCP servers. The group analyzed two concrete examples — the AWS Q Business tool and the GitHub Copilot assign-to-issue tool — then transitioned into Vinay's proposed framework for categorizing agent use cases across consumer, coding, and enterprise domains.

Production Agent Use Cases: Q Business

Luca described the Q Business tool from the AWS MCP server as a system that already existed independently and was wrapped with an MCP interface. The MCP wrapper operates as a single-shot stateless call, making a single tool call sufficient for the use case. Upon clarification from Vinay, Luca noted that the underlying Q Business API does support multi-turn interactions via a conversation ID — a parameter that a calling agent could manage explicitly if the wrapper surfaced it. Luca noted this aligns with SEP-2567 (explicit state handles), where session use cases can be handled by surfacing an ID as a tool parameter.

Vinay noted that session or conversation IDs should not be exposed directly to the agent, arguing these should be managed at the protocol or authorization level rather than requiring the LLM to handle them. Luca acknowledged this and noted that tasks were introduced specifically to lift this kind of low-value, undifferentiated work to the application level.

Production Agent Use Cases: GitHub Copilot

Luca described the GitHub Copilot "assign Copilot to issue" tool, which dispatches a Copilot instance to work on a GitHub issue and ultimately produce a pull request. The current implementation uses a polling mechanism — the MCP server holds the connection open and polls at one-second intervals, notifying the client via progress notifications.

Luca proposed that modeling this as a task would eliminate the need to maintain an active server connection throughout the operation. Under a task-based model, the polling interval would be assigned on the task object itself, and the tasks/get operation would retrieve the current state. Vinay confirmed that existing task semantics already solve this case, as it involves no elicitation or sampling — it is a one-shot long-running operation.

Task Steer Proposal

Luca referenced an existing proposal that proposes a task/steer method enabling multi-turn interactions with a task, under a model where tasks are used as an abstraction over agents. The author had originally suggested including it in the tasks extension itself. Luca noted he had not yet had time to fully review it. Vinay observed that this would change the semantics of how tasks currently operate. Luca explained this was the reason he had initially rejected it from the tasks extension — the scope was already large — but expressed interest in exploring it as a follow-on.

Framework for Categorizing Agent Use Cases

Vinay presented a document dividing agent use cases into consumer, coding, and enterprise domains, with interaction patterns categorized as:

Client-side multi-turn: The server is stateless; the host provides interaction history or additional context on each invocation.
Server-side multi-turn: A protocol-level identifier (task or otherwise) enables the server to persist state across invocations, governed by the server's lifecycle.
Agent definition: The server publishes how its tools or resources can be composed, enabling the host to construct agent behavior from that definition.

For consumer applications, Vinay used a shopping agent as an example of server-side multi-turn: a session identifier persists information across a shopping session, with individual tasks (buying a product, building a recipe) governed by the server's lifecycle. He noted that task lifecycles and session identifiers serve distinct purposes — a session spans multiple tasks.

Coding Agent Requirements

Vinay highlighted that coding agents have a distinguishing characteristic: a shared file system primitive and potentially a shared execution environment. Agent definitions in this context describe how agents can participate in a shared workspace.

Vinay described two patterns for coding: client-side multi-turn where the host grants access to shared state (e.g., a triage agent and a coding agent with different capabilities but shared workspace access), and server-side interactions where sensitive data constrains what can be exposed (e.g., a triage agent can describe what is being debugged but cannot share the underlying data). Luca noted that the server-side case maps directly onto the explicit state handles concept from SEP-2567, where an ID is associated with an underlying resource.

Enterprise Agent Requirements

Vinay described enterprise scenarios using an electronic health record (EHR) system as an example, where a hospital's client assistant interacts with an EHR agent. Enterprise use cases require prescriptive control over tool access due to compliance, regulatory, and data egress constraints. Vinay concluded that agent definition protocols may suffice for consumer-grade tools, but enterprise systems likely require more robust server-side primitives.

Events and Tasks Integration

Madhavi raised the relationship between trigger events and the current work on tasks. Luca noted that one thing tasks currently lack is a form of intermediate results, and events would be a natural fit for reporting progress from within a running task.

Update 5/27: This is the subject of a Triggers & Events WG proposal: https://github.com/modelcontextprotocol/experimental-ext-triggers-events/pull/2

Gemini and DevTools MCP Server Research

Madhavi mentioned ongoing research into how the Gemini and DevTools MCP servers manage file system interactions, observing that these servers appear to use multiple tool calls to interact with file system state rather than attempting to return everything in a single response. Luca expressed interest in hearing more as the research progresses.

Follow-ups

@LucaButBoring: Contact @SamMorrowDrums from GitHub to discuss the Copilot use case as a potential adopter of the task abstraction.
@vinoo999: Submit a pull request to the Agents WG repo summarizing the consumer/coding/enterprise interaction pattern framework.
Madhavi PDB: Research event notifications and existing patterns in the Gemini and DevTools MCP servers, and document findings.

7.2 KiB Raw Blame History