Amazon Quick brings ready-to-use AI agents to enterprise teams in AWS

Amazon Web Services is rolling out Amazon Quick, a new agentic workspace designed to help teams automate tasks across existing business tools without writing custom orchestration code. Unveiled at AWS’s "What’s Next with AWS" event on April 28, 2026, Quick aims to bridge the gap between AI-powered assistants and real-world workflows by grounding responses in a company’s actual data rather than generic model training.

Quick targets teams—not solo users—allowing one person to build a custom agent scoped to a specific dataset or workflow that the entire team can then use. Under the hood, it leverages Amazon Bedrock’s AgentCore and adopts the Model Context Protocol (MCP) as its standard for integrating external tools, ensuring compatibility with both AWS-native and third-party systems. All data processing occurs within an AWS IAM and VPC environment, inheriting the same security and compliance controls as other AWS workloads.

Five core components powering Quick’s agentic workflows

Amazon Quick bundles five distinct capabilities into a unified platform, each designed to address different aspects of team collaboration and automation:

• Spaces: Shared workspaces where teams centralize files, dashboards, and data sources. Agents operating within a Space remain grounded in that specific data, ensuring consistency and relevance in responses.
• Agents: Custom, domain-specific agents built on a team’s proprietary data. These agents can be created by one team member but used by everyone, reducing duplication of effort.
• Research: A multi-source synthesis engine that aggregates insights from internal documents, public web data, and third-party datasets to produce structured reports—ideal for competitive analysis or market research.
• Visualize (QuickSight integration): A built-in business intelligence layer that enables conversational access to dashboards, charts, and forecasting without requiring a separate BI tool.
• Automate (Quick Flows): Workflow automation that spans simple daily tasks to complex, multi-step processes, executing actions across multiple applications with minimal setup.

Users can access Quick through a web browser, mobile app, or a native desktop client currently in preview for macOS and Windows. The desktop client adds local file and calendar context capabilities, streamlining interactions without relying on browser-based access.

How Amazon Quick fits into AWS’s broader AI agent ecosystem

AWS is simultaneously developing two layers of its AI agent strategy: infrastructure and product. Amazon Bedrock AgentCore serves as the foundational layer for engineers who want to design custom agent systems, including runtime environments, memory management, gateways, and observability tools. Quick, by contrast, sits at the product layer—a ready-to-deploy, team-facing workspace that requires no custom orchestration code.

For engineering teams, this dual approach means AgentCore handles the technical backbone, while Quick provides a surface layer where non-technical users interact with the agents. Engineers build and deploy the agents, while teams use them as part of their daily workflows, creating a seamless handoff between technical development and practical application.

Behind the scenes: MCP integration and request lifecycle

A key differentiator for Quick is its use of the Model Context Protocol (MCP), an open standard that allows agents to connect to external systems without being locked into AWS-specific connectors. This means Quick can integrate with any MCP-compatible server, expanding its flexibility across diverse toolchains.

The request lifecycle begins when Quick receives a user prompt and ends when the response returns from the downstream API. Quick acts as the MCP client, while an external MCP server exposes tools via listTools and callTool endpoints. During registration, Quick discovers available tools and makes them accessible to any agent or automation within the workspace. Authentication flows through OAuth 2.0, with support for Dynamic Client Registration (DCR), enabling Quick to register itself automatically without manual credential setup.

Building a minimal MCP server for Quick: a practical example

Developers can create custom MCP servers to extend Quick’s functionality. Below is a minimal Python implementation using the mcp SDK to expose two Jira-related tools—get_ticket and list_open_tickets—that Quick can invoke. This server can run independently or on the AgentCore Runtime.

# Install dependencies
pip install mcp[server] httpx uvicorn

# server.py
from mcp.server import Server
from mcp.server.sse import SseServerTransport
from mcp.types import Tool, TextContent
import httpx
import json
from starlette.applications import Starlette
from starlette.routing import Route

app = Server("jira-quick-integration")

JIRA_BASE_URL = "
JIRA_TOKEN = "Bearer <your-token>"  # Load from AWS Secrets Manager in production

@app.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="get_ticket",
            description="Retrieve details for a single Jira ticket by issue key.",
            inputSchema={
                "type": "object",
                "properties": {
                    "issue_key": {
                        "type": "string",
                        "description": "The Jira issue key, e.g. ENG-1234"
                    }
                },
                "required": ["issue_key"]
            }
        ),
        Tool(
            name="list_open_tickets",
            description="List open Jira tickets assigned to a given user.",
            inputSchema={
                "type": "object",
                "properties": {
                    "assignee": {
                        "type": "string",
                        "description": "The Jira username or email of the assignee"
                    }
                },
                "required": ["assignee"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    headers = {"Authorization": JIRA_TOKEN, "Content-Type": "application/json"}
    async with httpx.AsyncClient() as client:
        if name == "get_ticket":
            key = arguments["issue_key"]
            resp = await client.get(
                f"{JIRA_BASE_URL}/rest/api/3/issue/{key}",
                headers=headers
            )
            resp.raise_for_status()
            data = resp.json()
            summary = data["fields"]["summary"]
            status = data["fields"]["status"]["name"]
            return [TextContent(type="text", text=f"Ticket {key}: {summary} (Status: {status})")]

This pattern allows developers to extend Quick’s capabilities by integrating internal tools, third-party APIs, or proprietary systems, all while maintaining alignment with AWS’s security and compliance frameworks. As teams adopt Quick, the platform’s ability to scale from simple automations to complex multi-step workflows could redefine how enterprises leverage AI in their daily operations.

Teams evaluating agentic workspaces should weigh Quick’s ready-to-use approach against the flexibility of building custom solutions. For organizations already invested in AWS ecosystems, Quick offers a compelling middle ground—bridging the gap between technical depth and practical usability without sacrificing control or security.