Start a free Elastic Cloud Serverless trial or log in to Elastic Cloud to follow along, and install the CLI via npm: 

Designing the Elastic CLI for people and AI agents

A useful side effect of building flexible tools for developers is that they’re more useful to AI agents, too. It’s also the tool that our Agent Skills now use to get things done, closing the loop that we opened in March 2026, when we said that a CLI for agent workflows was coming.

The CLI gives every public API across Elasticsearch, Kibana, and Elastic Cloud one shape: the same flags, input and output conventions, authentication method, and failure mode. Consistency is the ergonomic feature; everything else is built on it.

Agents need the same thing, only stricter. An agent won’t know how to craft a valid CLI command or notice if a tool “feels” wrong; it needs output it can parse and input it can validate before sending, along with failures it can branch on. Agents are now a first-class interface to Elastic, alongside people, whether they live on the platform or in your editor and terminal. Agent Skills, and now the CLI, are how we serve the second kind, so those needs are built into the core of the CLI rather than tacked on.

JSON input and output for every command

Agents love structured text, and almost every Elastic API already speaks JSON, so first-class JSON support was a hard requirement. Developers who are quick with a jq query will be equally satisfied.

• JSON output: Any command, like elastic version and elastic es indices delete ..., supports --json, which prints JSON-parseable output to stdout and nothing else. Failed commands print {"error": {"code": "...", "message": "..."}} to stderr.

• JSON input: Every command that takes input accepts JSON on stdin or via --input-file. Every top-level key in that JSON also works as a CLI argument, and inline arguments take precedence, so you can keep a big request body in a file and tweak a value or two per invocation.

• JSON Schema as --help output: Pass --help --json to any command, and it prints a valid JSON Schema for its input, which also feeds nicely into codegen tools. elastic cli-schema prints the whole command tree.

Exit codes that an AI agent can branch on

Agents loop on exit codes as much as they do over stdout. All failure modes are distinguishable from success, even if stdout and stderr are never read.

Safety rails: Keychain storage, allow lists, and validation

No model uses tools perfectly 100% of the time, so an agent-friendly CLI should provide safety rails wherever possible.

• Contexts and secret storage: Connection details live in named contexts in ~/.elasticrc.yml, kubectl-style; switch with --use-context. API commands never take credentials as flags. elastic config context add writes API keys to your OS keychain (macOS, Linux, Windows) and leaves a $(keychain:...) reference in the YAML; $(env:...), $(cmd:...), and $(file:...) work, too. Creating a Serverless project with --save-as writes its credentials straight to the keychain and never prints them, so nothing leaks into logs or LLM transcripts.

• Allowlists/blocklists: A commands.allowed (or commands.blocked) list in the config file, globally or per context, ensures that only the commands an administrator wants are runnable.

• Validation: Every command has a JSON Schema, so inputs are validated before any request is sent. Add --dry-run to any command that takes input, and it validates and exits without sending anything.

• Confirmation: Destructive commands prompt in a terminal. In a noninteractive session, where agents live, they refuse to run without --yes and say so in a structured error.

• Sanitization: Index, field, and pipeline names have length limits and forbidden characters. elastic sanitize index-name '<value>' (and field-name, pipeline-name, …) prints a version stripped of anything invalid.

Keeping API responses inside an agent's context window

Elastic APIs return a lot of data, and an agent’s context window is finite. Three controls help keep unnecessary text out of the context window:

• Field masks: --output-fields takes a comma-separated list, with dot notation for nested fields.

• String templates: For total control, --output-template takes a mustache-style template.

• Command profiles: --command-profile serverless (or default_profile: serverless in your config) hides Elastic Cloud Hosted commands and the Elasticsearch namespaces that don’t exist on Serverless. That means less to scroll past and less for an agent to guess wrong. It’s the profile we recommend for agents.

Control

What it does

Syntax

When to use

Field mask

Returns only the fields you name, using dot notation for nested fields

--output-fields 'name,version.number'

You want valid JSON back, just less of it. This is the default choice for agents parsing structured output.

String template

Renders the response through a mustache-style template

--output-template 'ES version: {{ version.number }}'

You need one value in a specific shape, for a shell variable, a log line, or a prompt.

Command profile

Hides commands and namespaces that don't apply to your deployment

--command-profile serverlessor default_profile: serverless

You want a smaller command surface so an agent has less to scroll past and less to guess wrong. This is recommended for agents.

Helpers for bulk ingest, scroll search, and msearch

Some of Elasticsearch’s most popular APIs have a learning curve, so elastic es helpers wraps them:

• scroll-search: Stream a large result set as NDJSON with paging handled for you.

• bulk-ingest: Ingest from a file, a directory, or stdin (NDJSON, JSON arrays, or CSV) with streaming, batching, concurrency, and retries.

• msearch: Send multiple searches in one request.

• watch: Print new documents from an index to stdout as they’re indexed. This is great for piping into logging tools.

elastic es and elastic kb are aliases for elastic stack elasticsearch and elastic stack kibana. If we don’t ship a command you need, elastic extension create scaffolds one for you.

Searching Elastic docs from the terminal

If you or your agents don’t know which API to use, elastic docs search (plus docs read and docs ask) searches Elastic’s documentation from the terminal, returning Markdown or --json. These are experimental. You’ll see a warning until you pass --accept-experimental, so explore, but don’t script against them yet.

Shell completion for Bash, Zsh, and Fish

Autocomplete hooks are available for Bash, Zsh, and Fish, and they always respect your commands.allowed or commands.blocked policy.

How Elastic Agent Skills use the CLI

Agent Skills teach an AI coding agent how an Elastic expert approaches a job; for example, which cluster health field is the verdict or how to stage a reindex so it doesn’t fall over. They capture process and judgment but not transport. A skill that embeds curl with an auth header has hard-coded a hostname, key, and runtime, and it breaks when any of those change.

So our skills now use a universal format that runs unchanged in any runtime that can execute the elastic CLI, including Claude Code, Codex, Cursor, and GitHub Copilot. The body refers to operations in HTTP shorthand (GET /_cluster/health, POST /_query), and an operations table at the end binds each to a CLI command. That table is the only place transport appears:

HTTP API (shorthand)

elastic CLI command

GET /{index}/_mapping

elastic es indices get-mapping --index '<index>'

POST /_query

elastic es esql query --format tsv --query "<esql>"

POST cloud:/api/v1/serverless/projects/elasticsearch

elastic cloud serverless projects search create --input-file <json> --wait --save-as <ctx>

Every universal skill also inherits a blunt preamble; that is, use the CLI, don’t guess credentials, don’t call the HTTP API directly, and never ask the user to paste an API key into the chat.

The two halves need each other. The skill supplies the expertise that the model doesn’t have, and the CLI supplies a way to act on it that’s validated, credential-safe, and scoped by your allowlist. Tell your agent to spin up a Serverless project and load products.csv into it, and the provisioning skill creates it with --save-as. The ingest skill dry-runs a mapping and loads with elastic es bulk, and the Elasticsearch Query Language (ES|QL) skill writes a query that parses on the first try. Every step returns JSON, exits non-zero on failure, and can only do what your policy allows.

Skills for Elastic Cloud onboarding and provisioning, Elastic Workflows, and Kubernetes investigation are available today. Skills for Elasticsearch query, ingest, reindex, and index design, plus Kibana dashboards and alerting, are close behind.

What’s in the Elastic CLI technical preview, and what’s next

The preview covers all public Elasticsearch Serverless, Kibana Serverless, and Elastic Cloud APIs. Hosted-only 9.x Elasticsearch API coverage is nearly 100%, and hosted-only 9.x Kibana APIs will be added soon.

We’re actively planning more developer experience work, including broader coverage for all supported stack releases, more helpers for common workflows, more skills in the public catalog, and loading the same skills into agents that run on the Elastic platform itself. What shapes that list is hearing how you and your agents use the CLI. Tell us what’s awkward and what’s missing, along with what you’d automate next.

Install the Elastic CLI and Agent Skills

The Elastic CLI is available now on npm (Node.js 22+). Install it and the skills together:

Then, add a context and check it:

Even without a project, you can start a free Serverless trial in about a minute, with no credit card. If you already have a project, log in and create API keys for Elastic Cloud and your Elasticsearch clusters. Before pointing an agent at anything real, start with a trial project, a read-only key, and a scoped commands.allowed list. Be sure to take five minutes to read the security notes in the skills repo.

Replace all those curl commands in your Bash scripts, and add some usage instructions to your AGENTS.md. Then let your agent’s skills work efficiently and accurately with our APIs. Let us know what you think, and don’t hesitate to open an issue if you find a bug or if your use case isn’t well supported. Your feedback directly shapes what we build next.

Elastic CLI and Agent Skills resources

• Elastic CLI on GitHub and CLI documentation

• Elastic Agent Skills on GitHub

• agentskills.io specification

• Elastic Cloud Serverless documentation

• Report a CLI issue · Report a skills issue · Discuss

At its core, this solution combines the power of Elasticsearch's search capabilities with Amazon's serverless AI infrastructure. Here's how it works:

• Your natural language questions are processed through the MCP server that is deployed on Amazon Bedrock AgentCore Runtime

• The MCP server translates these questions into precise Elasticsearch queries

• Results are returned in human-readable format, making your data instantly accessible

• All of this happens in a secure, scalable environment that's production-ready, deployed on Amazon Bedrock AgentCore Runtime

In this blog post, we'll explore how to:

• Deploy Elastic's MCP server on Amazon Bedrock AgentCore Runtime

• Transform local MCP prototypes into production-ready solutions

• How to Build Conversational Interfaces on top of Elasticsearch

• Implement secure, scalable AI agent architectures

Background

Model Context Protocol (MCP)

MCP is an open protocol that revolutionizes how businesses interact with their data through AI. Unlike traditional Retrieval-Augmented Generation (RAG) systems that simply retrieve documents, MCP enables AI agents to dynamically construct and execute complex tasks in real-time, mirroring the flexibility of human problem-solving

In practice, this means a business analyst can ask a series of increasingly specific questions about market trends, and the MCP-powered system will intelligently select and combine the appropriate data sources and analytical tools to provide comprehensive answers, while still maintaining context, allowing for follow-up questions without repetition.

For instance, when analyzing a product launch, the AI might integrate data from sales reports, customer feedback, and social media sentiment, orchestrating multiple tools simultaneously to provide a holistic view, thus enabling businesses to uncover deeper insights and make informed decisions, all through natural language interactions with their data systems.

Agents

Agents are AI-powered software applications that can think, plan, and act to achieve specific goals with minimal human supervision. They use foundation models (advanced AI models) to understand and complete complex tasks.

There are two types of AI agents.

Knowledge AI agents

These agents focus on enterprise knowledge. They gather context from company data — documents, logs, dashboards, communications, and customer records — and use that information to complete business tasks.

Example: A knowledge AI agent that can search across contracts, policies, and past tickets to help a customer support representative instantly resolve an issue.

General AI agents

These agents go further. They can understand goals and autonomously execute tasks on behalf of a user in broader, cross-domain workflows.

Example: A general AI agent that books travel, manages schedules, and negotiates with other systems to complete a user’s request end-to-end.

Elastic’s role in agentic AI

For knowledge AI agents: Elastic enables secure access to enterprise data, retrieves relevant context, and grounds responses in facts.

For general AI agents: Elastic serves as the knowledge store and context engine, providing trusted information so agents can perform more complex, goal-driven tasks.

In short, Elastic isn’t just storing data; it’s making enterprise knowledge usable, actionable, and AI-ready. This is the foundation for building intelligent agents that both understand and act.

AWS partnership and MCP server

Elastic has earned the AWS Generative AI Competency status. This recognition is awarded to AWS partners who deliver cutting-edge generative AI solutions that drive measurable gains in business efficiency, creativity, and productivity

Elastic also integrates with the Model Context Protocol (MCP), providing a seamless way for AI agents and applications to interact with Elasticsearch data through natural language conversations.

With the MCP server, you can connect to Elasticsearch directly from any MCP client — such as Claude Desktop, MCP Inspector, or an agentic application. The Elasticsearch MCP server is free to use (though infrastructure and Elasticsearch cluster costs may apply).

And with Amazon Bedrock models (such as Anthropic’s Claude) supporting MCP clients, organizations can now deploy intelligent, data-aware agents more easily and powerfully than ever before.

Amazon Bedrock AgentCore

Amazon Bedrock AgentCore is an enterprise-grade orchestration platform designed for scalable AI agent deployment and management. 

• The platform provides serverless runtime environments with session isolation capabilities, enabling concurrent agent operations across multiple frameworks.

• It implements memory management systems for both session-state and persistent storage, facilitating context-aware model interactions and learning capabilities.

• The architecture includes observability features with granular logging, metrics collection, and advanced debugging capabilities for agent trajectory analysis.

• The platform's robust identity and access management layer enables secure service-to-service authentication and fine-grained authorization controls for AWS and third-party service integrations.

It features a protocol-agnostic gateway for API transformations and tool discovery, supporting MCP-compliant interfaces. The infrastructure also includes containerized browser instances for web automation workflows and isolated compute environments for secure code execution. This end-to-end solution eliminates the need for building custom infrastructure components while maintaining enterprise security and compliance standards.

Solution overview

High-level architecture

The architecture consists of four main components:

1. Python client: Handles user interactions and AWS authentication

2. Amazon Bedrock AgentCore Runtime: Provides serverless hosting and session management

3. Elastic MCP server: Processes MCP protocol requests and queries Elasticsearch

4. Elasticsearch cluster: Stores and indexes the searchable data

Step-by-step workflow walkthrough

1. User authenticates using an authentication mechanism such as OAuth.

2. User access secured Client application running in a Customer AWS account using authenticated credentials.

3. The client application invokes a Supervisor Agent that further invokes and orchestrates other Agents.

4. All the agents are deployed on Amazon AgentCore Runtime and their tools are made available for the Agents, including Elastic’s MCP server and its tools.

5. Foundation Models are available for the agentic AI application through Amazon Bedrock.

6. Elastic Cloud is deployed on AWS and its endpoints are accessed by the Elastic MCP Server. Elastic MCP server automatically crafts the required queries, runs the queries against the Elastic data and fetches the response back to the Supervisor Agent.

7. Supervisor Agent responds back to the end user via the Client Application.

Implementation guide

Please refer to this GitHub repo to get a hands-on experience of how this solution can be implemented. Pay close attention to the prerequisites before getting started.

Step 1: Deploy Elastic MCP server to ECR

The automated deployment script handles the entire container build and upload process:

Here is what the script does when you execute:

1. Downloads the official Elastic MCP server repository

2. Builds Docker container using Dockerfile-8000

3. Creates ECR repository with image scanning enabled

4. Uploads container image to ECR with proper tagging

Step 2: Create AgentCore Runtime host

Navigate to the AWS Console and configure your AgentCore Runtime:

1. Access AgentCore: Go to Amazon Bedrock AgentCore > Build and Deploy > Agent Runtime > Host Agent

2. Basic configuration: Click on “Host Agent” and give it a meaningful name if you prefer. Point to the Container Image you have uploaded to Amazon ECR.

3. Service role: Choose "Create and use a new service role"

4. Protocol settings: Choose MCP, and for the Inbound Identity, select Use IAM username

5. Environment variables: Finally, configure your Elasticsearch endpoints and pass them as environment variables to your Docker container.

6. After creating the host agent, go ahead and copy the Agent Runtime ARN from the "View invocation code" section. Here is an example:

Step 3: Configure Python client

Install dependencies:

Go ahead and initialize a virtual environment and install the Python libraries.

Update Agent ARN in my_mcp_client_remote.py:

Next, update the Python MCP client with the agent ARN you obtained in the previous steps.

Here are the key client components in this Python file.

AWS authentication class:

MCP request formation / payload:

Step 4: Run the client

Execute the Python client to test the integration. This Python program implements an asynchronous client for interacting with Amazon Bedrock AgentCore, specifically designed to query event information. The code utilizes AWS SigV4 authentication and consists of two main functions: test_mcp_endpoint() and chat_with_agentcore(). The first function demonstrates basic API interaction by listing available tools and performing a search query, while the second function implements a more sophisticated search functionality specifically for events in Paris.

The program uses the httpx library for async HTTP requests and handles Server-Sent Events (SSE) responses, parsing and displaying event details including names, venues, dates, and descriptions. The authentication is managed through a custom AWSAuth class that handles AWS SigV4 signing of requests. The code includes comprehensive error handling and formatted output display, making it suitable for both testing and production use cases.

Use case demonstrations

Use case 1: Data discovery

Scenario: Finding events in a specific city using natural language.

Query: "Events in Paris"

MCP request: Here is the payload you supply to the Amazon Bedrock Agentcore Runtime.

Response: And here is the response you get after Elastic’s MCP server runs a query in Elastic Search AI Platform and returns the result.

Use case 2: Elastic MCP tool discovery

Scenario: Discovering the available MCP tools that Elastic’s MCP server offers.

MCP request:

This returns a list of available tools that the MCP server provides, enabling dynamic tool discovery.

Use case 3: Complex search queries

Scenario: Advanced filtering with multiple criteria. You can run more advanced Elastic Search Query Language based queries, like one shown below.

Query: Events with specific price ranges, dates, and categories.

MCP request:

How it works (technical deep dive)

MCP implementation

The Model Context Protocol uses JSON-RPC 2.0 format for all communications:

Key protocol features:

• Stateless operation: Each request is independent with session isolation

• Tool discovery: Dynamic discovery of available capabilities

• Structured responses: Consistent response format across all tools

• Error handling: Standardized error reporting and recovery

AWS authentication flow:

Session management

AgentCore automatically adds Mcp-Session-Id headers for session isolation:

• Each client session gets a unique identifier

• Stateless servers can maintain conversation context

• Automatic cleanup of inactive sessions

Response processing pipeline

1. Server-Sent Events (SSE): Responses come as data: {...} in JSON format

2. JSON parsing: Extract JSON from SSE wrapper

3. Content extraction: Parse the MCP result structure

4. Data formatting: Convert Elasticsearch results to user-friendly format

Cleanup

After you have played around with this setup, if you would like to clean up the environment, please follow the steps outlined below.

Delete AgentCore Runtime:

1. Navigate to Amazon Bedrock AgentCore in AWS Console

2. Select your agent runtime

3. Click "Delete" and confirm

Remove ECR repository:

Clean local environment:

Conclusion

By deploying Elastic's MCP server on Amazon Bedrock AgentCore Runtime, we've created a powerful, scalable, production-ready solution for natural language interaction with Elasticsearch data. This implementation opens up new possibilities for data exploration and analysis, making complex queries accessible through simple conversations.

Key takeaways include:

• Seamless integration: MCP protocol enables natural language querying of complex data

• Production scalability: AgentCore provides enterprise-grade hosting with minimal configuration

• Developer productivity: Transform local prototypes to production with minimal code changes

• Security first: Built-in AWS security and authentication mechanisms

Potential applications can be in any of the following areas of implementation:

• Customer support: Natural language querying of support ticket databases

• Business intelligence: Conversational analytics for business metrics

• Content discovery: Intelligent search across document repositories

• IoT data analysis: Natural language queries for sensor and telemetry data

Additional resources:

• Amazon Bedrock integration documentation

• Elastic MCP server documentation