Demo Create AI Agents using AWS MCP Servers In action

This lesson demonstrates a two-way integration between Slack and KAgent:

Slack -> KAgent: a user invokes a Slack slash command; the Slack bot forwards the query to a KAgent via the A2A protocol; the agent runs tools and returns results to Slack.
KAgent -> Slack: the agent proactively posts notifications to a Slack channel using a Slack MCP server.

Below are the key components for this integration.

A screenshot of a code editor (likely VS Code) with a project sidebar on the left and an open text file on the right. The document shows an ASCII-style "KEY COMPONENTS" section describing a Slack app, a Python Slack bot, and a kagent agent.

This article does not cover Slack app creation specifics because that depends on your organization’s Slack configuration. At a minimum you will need a bot token and an app token with appropriate scopes (chat:write and commands) and Socket Mode enabled for local development.

Key components (overview)

Component	Purpose	Example / Notes
Slack App	Provides tokens and scopes to interact with the workspace	Create at api.slack.com/apps — requires `SLACK_BOT_TOKEN`, `SLACK_APP_TOKEN`, `chat:write`, `commands`, Socket Mode for local development
Slack Bot (Python Bolt)	Receives Slack events and forwards queries to KAgent via A2A	Runs locally with `uvicorn main:app --reload`. Listens for `/mykagent` slash command and formats responses as Slack Block Kit
KAgent Agent	Executes LLM + tools inside Kubernetes	Deployed in the `kagent` namespace and exposed via A2A
A2A Protocol	REST API for external systems to invoke agents	Endpoint pattern: `/api/a2a/{namespace}/{agent-name}/` — use backticks when documenting (e.g., `/api/a2a/{namespace}/{agent-name}/`)
MCP Servers	Provide tool integrations to agents (Slack, GitHub, PagerDuty, etc.)	Slack MCP server exposes tools like `slack_post_message`, `slack_get_channel_history`, etc.

Notes:

Use backticks for endpoints that contain braces (e.g., /api/a2a/{namespace}/{agent-name}/).
This example uses Socket Mode for the local Slack bot with Python Bolt.

Local connection and setup (development flow)

A typical local development flow:

Port-forward the KAgent controller so your local machine can reach the A2A endpoint:

kubectl port-forward -n kagent svc/kagent-controller 8083:8083

Set the A2A URL environment variable (pointing to the agent you will deploy). Use backticks when copying the path:

export KAGENT_A2A_URL="http://127.0.0.1:8083/api/a2a/kagent/my-k8s-agent/"

Start the Slack bot locally (example for a uvicorn-based app):

uvicorn main:app --reload

Test from Slack using the configured slash command, e.g.:

/mykagent show me the pods in the cluster

Environment variables (.env example)

Store Slack tokens and the A2A URL in a .env file or secret manager:

SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-1-...
KAGENT_A2A_URL=http://127.0.0.1:8083/api/a2a/kagent/my-k8s-agent/

Do not commit tokens or secrets to source control. Use Kubernetes Secrets or a secret manager for production credentials. Rotate tokens if they are accidentally exposed.

Slack -> KAgent request flow (high-level)

USER (Slack) types a slash command (e.g., /mykagent "show me pods").
Slack delivers the command event (via Socket Mode) to the local Slack bot.
SLACK BOT (Python Bolt) extracts the query and performs an HTTP POST to the A2A endpoint configured in KAGENT_A2A_URL.
The A2A request hits the KAgent controller (port-forwarded to localhost).
The controller routes the request to the appropriate agent pod.
The agent processes the query using its LLM, chooses and executes tools (e.g., Kubernetes resource tools), and crafts a response.
The agent returns the response via A2A; the Slack bot posts formatted output back to the Slack channel.

Example HTTP request to A2A (local dev):

POST http://127.0.0.1:8083/api/a2a/kagent/my-k8s-agent/
Payload: { "input": "show me pods", ... }

Running the bot and deploying the agent

Start the Slack bot locally:

uvicorn main:app --reload
# Example log:
# INFO:root:Starting kagent Slack bot

Deploy the agent manifest into the cluster:

kubectl apply -f slack-k8s-agent.yaml
# Example output:
# agent.kagent.dev/my-k8s-agent created

Check agent status:

kubectl get agent -n kagent
# NAME            TYPE          READY   ACCEPTED
# my-k8s-agent    Declarative   False   True

Retrieve the agent card from the A2A controller (validates the path and capabilities):

curl http://127.0.0.1:8083/api/a2a/kagent/my-k8s-agent/.well-known/agent.json

Example JSON response (truncated):

{
  "name": "my_k8s_agent",
  "description": "My Kubernetes Agent",
  "url": "http://kagent-controller.kagent.svc.cluster.local:8083/api/a2a/kagent/my-k8s-agent/",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": true
  },
  "defaultInputModes": ["text"],
  "defaultOutputModes": ["text"],
  "skills": [
    {
      "id": "answer-questions-about-your-cluster",
      "name": "Answer Questions About Your Cluster",
      "description": "Answer questions about your Kubernetes cluster",
      "tags": ["kubernetes"],
      "inputModes": ["text"],
      "outputModes": ["text"]
    }
  ]
}

Once the agent shows READY in the KAgent UI, invoke it via Slack.

Example Slack query -> agent response

User input:

/mykagent get the list of pods running in the cluster

Agent response (example formatted text):

Here are the pods running in the cluster across all namespaces:

Namespace: kagent
- kagent-controller-6f546c65bd-ckk6s
- kagent-grafana-mcp-597df4c7f4-r4fdq
- kagent-kmcp-controller-manager-86b48b656d-l8zdb
- kagent-querydoc-7dc78dc9d7-pqf92
- kagent-tools-6d6695c5-rw7rz
- kagent-ui-5757fccb58-bsbbc
- my-k8s-agent-7b98575b68-kds2f

Namespace: kube-system
- metrics-server-67c9654d97-dc7tm
- metrics-server-67c9654d97-g9crq

All pods listed are in Running status. How can I assist you further?

This demonstrates the full round-trip: Slack -> Slack bot -> A2A -> agent -> tools -> response -> Slack.

KAgent -> Slack (Agent-initiated messages)

Agents can proactively post to Slack channels by calling Slack MCP tools. Typical flow:

Agent determines a message/alert should be posted to Slack.
Agent calls a Slack MCP tool such as send_message_to_slack or slack_post_message.
The Slack MCP server performs an HTTP POST to Slack API chat.postMessage.
The message appears in the configured Slack channel.

Schematic:

KAGENT AGENT (in Kubernetes)
  -> call send_message_to_slack
SLACK MCP SERVER (in Kubernetes)
  -> POST chat.postMessage to Slack API
SLACK WORKSPACE
  -> message appears in channel

Deploying and configuring the Slack MCP server

A Slack MCP server is an MCPServer custom resource. A minimal manifest looks like this:

apiVersion: kagent.dev/v1alpha1
kind: MCPServer
metadata:
  name: slack-mcp
  namespace: kagent
spec:
  deployment:
    image: "node:latest"
    port: 3000
    cmd: ["npx"]
    args:
      - "-y"
      - "@modelcontextprotocol/server-slack"
  secretRefs:
    # secret references for Slack credentials (see your manifest)

Create a Kubernetes Secret containing Slack credentials (bot token, team ID, channel IDs) and apply the manifest:

kubectl apply -f slack-mcp.yaml
kubectl get mcpserver -n kagent
# NAME        READY   AGE
# slack-mcp   True    14s

When the Slack MCP server is running, tools such as slack_post_message, slack_get_channel_history, and slack_add_reaction are available to agents. Confirm visibility in the KAgent UI.

A screenshot of a web UI for "kagent" (localhost:8080/servers) showing a list of server/integration entries. The expanded item is kagent/slack-mcp with multiple Slack actions listed (e.g., slack_add_reaction, slack_get_channel_history).

Granting the agent Slack posting permissions

Steps to allow agents to post into Slack:

Create a Kubernetes Secret with Slack credentials (bot token, team ID, channel IDs).
Update your agent manifest to include Slack MCP tools (e.g., slack_post_message) in the agent’s tool list.
Apply the updated agent manifest and wait for KAgent to reconcile. It may take a minute for new tools to become available.

Example:

kubectl apply -f slack-k8s-agent.yaml
# agent.kagent.dev/my-k8s-agent configured

Example instruction you can give the agent:

Get the list of deployments on the cluster and post it to the Slack channel "cluster-info".

Example tools executed:

get_resource_information (fetch deployments)
slack_post_message (post formatted message to Slack channel)

Example channel output:

List of deployments on the cluster:

Namespace: kagent
- kagent-controller
- kagent-grafana-mcp
- kagent-kmcp-controller-manager
- kagent-querydoc
- kagent-tools
- kagent-ui
- my-k8s-agent
- slack-mcp

Namespace: kube-system
- metrics-server

You can deploy multiple Slack apps / MCP servers to support different teams, channels, or clusters as needed.

Quick reference commands

Task	Command
Port-forward KAgent controller	`kubectl port-forward -n kagent svc/kagent-controller 8083:8083`
Start Slack bot	`uvicorn main:app --reload`
Apply agent manifest	`kubectl apply -f slack-k8s-agent.yaml`
Retrieve agent card	`curl http://127.0.0.1:8083/api/a2a/kagent/my-k8s-agent/.well-known/agent.json`

Closing

This lesson covered a two-way integration pattern between Slack and KAgent:

Slack -> KAgent: Slack commands are forwarded to agents via the A2A protocol; agents execute tools and return results back to Slack.
KAgent -> Slack: Agents post messages or alerts to Slack by invoking MCP tools exposed by a Slack MCP server.

You can reuse this pattern to integrate agents with other MCP servers (GitHub, PagerDuty, etc.) to extend agent capabilities across platforms.

Links and references

Slack API: chat.postMessage
Socket Mode (Slack)
Kubernetes Documentation
KAgent (project docs) (check your cluster’s docs for KAgent-specific manifests)

Introduction

KAgent Installation & Architecture Overview

KMCP Installation & Overview

System Prompts for AI Agent Building

Debugging AI Agents

Creating AI Agents - Bring It all together

Demo Create AI Agents using AWS MCP Servers In action

Key components (overview)

Local connection and setup (development flow)

Environment variables (.env example)

Slack -> KAgent request flow (high-level)

Running the bot and deploying the agent

Example Slack query -> agent response

KAgent -> Slack (Agent-initiated messages)

Deploying and configuring the Slack MCP server

Granting the agent Slack posting permissions

Quick reference commands

Closing

Links and references

Watch Video

​Key components (overview)

​Local connection and setup (development flow)

​Environment variables (.env example)

​Slack -> KAgent request flow (high-level)

​Running the bot and deploying the agent

​Example Slack query -> agent response

​KAgent -> Slack (Agent-initiated messages)

​Deploying and configuring the Slack MCP server

​Granting the agent Slack posting permissions

​Quick reference commands

​Closing

​Links and references

Watch Video

Key components (overview)

Local connection and setup (development flow)

Environment variables (.env example)

Slack -> KAgent request flow (high-level)

Running the bot and deploying the agent

Example Slack query -> agent response

KAgent -> Slack (Agent-initiated messages)

Deploying and configuring the Slack MCP server

Granting the agent Slack posting permissions

Quick reference commands

Closing

Links and references