Skip to main content

​
Overview

Elitea MCP Tools is a built-in internal tool that connects a conversation agent to ELITEA’s own Model Context Protocol (MCP) server. Once enabled, the agent can discover and call other agents and toolkit operations that have been explicitly made available through MCP — all from within a single conversation, without the user needing to pre-wire every dependency upfront.

Platform-Native MCP Access

Uses the same secure MCP server that external MCP clients use, but from inside a conversation — no separate connection needed.

Agent Invocation

Call other agents tagged with mcp as tools — pass a task, get back the agent’s full response.

Toolkit Tool Execution

Invoke individual tools from any toolkit with Available via MCP enabled — each selected tool becomes a direct callable.

No External Credentials

Authentication is inherited from the current user session — no additional secrets or setup required.
Use Elitea MCP Tools when you want a coordinator or meta-agent to discover and delegate to other agents at runtime — without hardcoding every child agent in the configuration. It’s also the right choice when you need an agent to invoke toolkit operations dynamically, based on what the conversation requires.

​
Prerequisites

  • MCP Enabled: MCP features must be enabled on the platform. If the Elitea MCP Tools toggle does not appear in the Internal Tools list, contact your Elitea administrator.
  • Permission Level: User role with conversation or agent edit access
  • Agents tagged with mcp: To appear as callable tools, agents must have the mcp tag applied. Agents without this tag are not listed, regardless of publish status.
  • MCP-Available Toolkits (optional): Toolkits with Available via MCP enabled in their settings, so their individual tools are callable.

​
How It Works

When Elitea MCP Tools is enabled, the agent connects to ELITEA’s built-in MCP server, which exposes two types of callable resources: How a tool call works
  1. The agent decides to call a resource — for example, PR_Review_Agent with task: "Review PR #42"
  2. The MCP server resolves the name and routes the call:
    • Agent call → runs the full agent prediction pipeline and returns the agent’s final reply
    • Toolkit tool call → executes the tool with the provided arguments and returns the result as JSON
  3. The response is returned to the calling agent, which incorporates it into its reasoning
Both agent and toolkit tool names are derived from the resource’s display name: any character that is not a letter, digit, underscore, or hyphen is replaced with _. For example, "PR Review Agent" → PR_Review_Agent, and "My GitHub Toolkit" with tool create_issue → My_GitHub_Toolkit_create_issue. Names that collide after normalisation — the second occurrence is silently skipped, so keep resource names distinct.

​
Enabling Elitea MCP Tools

Elitea MCP Tools can be toggled on per conversation or saved as part of an agent’s configuration for persistent use across all conversations with that agent.
If Elitea MCP Tools does not appear in the Internal Tools list, the MCP feature may be disabled at the platform level. Contact your Elitea administrator.

​
In a Conversation

Enable Elitea MCP Tools for an ad-hoc conversation.
  1. Navigate to your conversation.
  2. Locate the chat input toolbar at the bottom of the screen.
  3. Click the + icon in the toolbar to open the menu.
  4. Hover over Internal Tools to reveal the flyout panel.
  5. Find Elitea MCP Tools in the list and click the toggle to enable it.
  6. A success toast notification appears: “Internal tools configuration updated”.
  7. Click anywhere outside the panel to close it.
Elitea MCP Tools Access Once enabled, the agent has access to all MCP-exposed tools in that conversation. The agent can call them as needed based on the conversation flow and user instructions.

​
In Agent Configuration

Configure Elitea MCP Tools as part of an agent’s saved configuration so it is active for all new conversations using that agent.
  1. Navigate to Agents in the main menu.
  2. Select the agent you want to configure or create a new agent.
  3. Within the TOOLS section, locate the INTERNAL TOOLS subsection.
  4. Find the Elitea MCP Tools toggle. If it is not visible, click Show all to expand the full list.
  5. Click the Elitea MCP Tools toggle to enable it.
  6. Click Save at the top of the configuration page.
  7. New conversations created with this agent will have Elitea MCP Tools active by default.
Elitea MCP Tools Access
When many platform agents and toolkits are available, consider also enabling Smart Tools Selection to reduce token usage from binding all discovered tools upfront.

​
Available Tools at Runtime

The exact tools the agent sees at runtime depend on your project’s configuration.

​
Agent Tools

Agents that have the mcp tag applied are exposed as callable tools. Each such agent produces one tool:
Agents without the mcp tag do not appear as tools, even if they are published. Apply the mcp tag to an agent in its settings to make it callable via Elitea MCP Tools.

​
Toolkit Tools

Toolkits with Available via MCP turned on in their MCP Options section expose their selected tools individually:

​
Using Elitea MCP Tools

Once enabled, the agent automatically has access to all discovered tools. No additional prompting or configuration is needed — the agent uses them based on the task requirements.

​
Example Interaction

User: “List all open pull requests from the GitHub toolkit and ask the code review agent to review each one.” Setup required:
  • GitHub toolkit has Available via MCP enabled and list_pull_requests in its selected tools
  • The code review agent has the mcp tag applied
Behind the Scenes:
  1. The agent calls My_GitHub_Toolkit_list_pull_requests (normalised from "My GitHub Toolkit" + list_pull_requests) to fetch open PRs
  2. For each PR, the agent calls Code_Review_Agent with a self-contained task that includes the PR title and diff inline
  3. The code review agent runs its full prediction pipeline and returns its findings as text
  4. The calling agent collects all reviews and presents a consolidated summary to the user

​
Example Scenarios

Scenario: A meta-agent that delegates tasks to specialised agents at runtime, without pre-wiring every dependency in the configuration.Setup:
  • Elitea MCP Tools: Enabled on the coordinator agent
  • Reporting Agent and QA Agent both have the mcp tag applied
User Request:
Summarise the last sprint and send the report through the reporting agent, then run the regression tests using the QA agent.
Workflow:
  1. Coordinator discovers available agent tools from the MCP server
  2. Calls Reporting_Agent with task: "Generate a sprint summary for the last sprint. Include completed items, blockers, and carry-overs."
  3. Receives the sprint report as text
  4. Calls QA_Agent with task: "Run the regression test suite and return the pass/fail summary."
  5. Receives the test results
  6. Combines both outputs and returns a single status update to the user
The coordinator never needed hardcoded references to the child agents — adding a new agent with the mcp tag makes it immediately available.
Scenario: A DevOps engineer wants an agent that bridges Jira and GitHub using natural language — finding tickets, merging their PRs, and updating statuses.Setup:
  • Elitea MCP Tools: Enabled
  • Dev GitHub toolkit — Available via MCP on; selected tools include list_pull_requests, merge_pull_request
  • Project Jira toolkit — Available via MCP on; selected tools include search_issues, update_issue
Exposed tool names (after normalisation):
  • Dev_GitHub_list_pull_requests, Dev_GitHub_merge_pull_request
  • Project_Jira_search_issues, Project_Jira_update_issue
User Request:
Find all Jira tickets marked "Ready for Release" and merge the associated GitHub pull requests.
Workflow:
  1. Agent calls Project_Jira_search_issues with JQL status = "Ready for Release"
  2. For each ticket, extracts the linked PR number from the ticket fields
  3. Calls Dev_GitHub_merge_pull_request for each PR
  4. Calls Project_Jira_update_issue to transition each ticket to “Released”
  5. Returns a summary: merged PRs and updated Jira tickets
Scenario: A QA team uses one coordinator agent to orchestrate test execution and bug filing across dedicated specialist agents and a Jira toolkit — all resolved at runtime.Setup:
  • Elitea MCP Tools: Enabled on the coordinator agent
  • Test Runner Agent — mcp tag applied; runs the test suite and returns results
  • Failure Analysis Agent — mcp tag applied; classifies failures as known regressions or new bugs
  • QA Jira toolkit — Available via MCP on; selected tools include create_issue
User Request:
Run today's regression suite, analyse any failures, and log new bugs.
Workflow:
  1. Coordinator calls Test_Runner_Agent with task: "Run the full regression suite and return pass/fail per test case."
  2. Agent receives structured results with failure details
  3. Coordinator calls Failure_Analysis_Agent with task: "Classify the following failures as known regressions or new bugs: {failures_list}"
  4. Analysis agent returns a categorised list
  5. For each new bug, coordinator calls QA_Jira_create_issue with the failure details
  6. Coordinator sends a final summary: tests run, failures found, bugs filed

​
Troubleshooting

The toggle only appears when MCP features are enabled at the platform level. Contact your Elitea administrator and ask them to enable MCP exposure and MCP in menu in the platform configuration.
Agents are only listed if they have the mcp tag applied. Publish status alone is not sufficient.To expose an agent:
  1. Open the agent in the Agents menu
  2. Go to the agent’s settings and add the mcp tag
  3. Save the agent
The agent will now appear as a tool when Elitea MCP Tools is enabled.
Toolkit tools are only exposed when the toolkit has Available via MCP enabled in its configuration. Go to Toolkits, open the toolkit, locate the MCP Options section, and enable the toggle. Only selected_tools within that toolkit will be exposed — verify the correct tools are selected.
Tool names are derived from display names: any character outside [A-Za-z0-9_-] is replaced with _. If two resources produce the same normalised name, only the first is exposed and the second is silently skipped.Make names clearly distinct. For example, "GitHub - Frontend Repo" and "GitHub - Backend Repo" normalise to different names, while "GitHub (Frontend)" and "GitHub Frontend" both become GitHub_Frontend_ and may collide.Rename conflicting agents or toolkits and verify the resulting normalised names are unique before relying on them.
Agent tool calls run the full agent prediction pipeline, which can take significant time for complex agents. If timeouts occur:
  • Ensure the target agent’s LLM is healthy and its configuration is complete
  • Check if the target agent has its own toolkits that may be failing to initialise
  • Simplify the task argument — the called agent must be able to complete it independently
Toolkit tool execution uses the current user’s session credentials. Verify:
  • The user has access to the project containing the toolkit
  • The toolkit’s stored credentials (API keys, tokens) are valid and not expired
  • The toolkit’s Available via MCP option is still enabled
  • Expose Elitea Tools via MCP - Enable toolkit tools for ELITEA’s MCP server so they appear as callables when Elitea MCP Tools is active
  • Elitea MCP Server (SSE) - Connect external MCP clients to ELITEA’s built-in MCP server — the same server this feature uses internally
  • Smart Tools Selection - Reduce token usage when many agent and toolkit tools are available — pairs well with Elitea MCP Tools
  • Swarm Mode - Another multi-agent pattern for tightly coupled agent handoffs with shared context
  • Agent Publishing - Publish an agent version before tagging it with mcp to make it callable via Elitea MCP Tools
  • Remote MCP Servers - Add external MCP servers to your project as toolkits, complementing the platform’s built-in MCP capabilities
  • Agent Configuration - Creating and configuring agents
  • Conversation Management - Managing conversations and settings