ateam-mcp
ateam-mcp lets AI assistants build, validate, deploy, test, and manage production multi-agent solutions on the ADAS platform through MCP tools.
Onboard and authenticate:
ateam_bootstrap,ateam_auth.Learn the platform:
ateam_get_spec,ateam_get_workflows,ateam_get_examples.Build, validate, and deploy:
ateam_build_and_run,ateam_redeploy,ateam_create_connector,ateam_create_plugin,ateam_upload_connector.Inspect and manage solutions/skills/connectors:
ateam_list_solutions,ateam_get_solution,ateam_show_skill_minimal,ateam_show_solution_minimal,ateam_get_connector_source,ateam_delete_solution,ateam_delete_skill,ateam_delete_connector.Test and debug runtime behavior:
ateam_test_skill,ateam_test_status,ateam_test_abort,ateam_test_connector,ateam_test_notification,ateam_conversation,ateam_test_pipeline,ateam_test_voice.Make surgical updates:
ateam_patch.Version and sync through GitHub:
ateam_github_push,ateam_github_pull,ateam_github_status,ateam_github_read,ateam_github_patch,ateam_github_write,ateam_github_log,ateam_github_diff,ateam_github_promote,ateam_github_rollback,ateam_github_list_versions,ateam_verify_consistency.Run cross-tenant admin sync/status with master key:
ateam_status_all,ateam_sync_all.
Allows building, validating, and deploying multi-agent systems through ChatGPT using the ADAS platform.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ateam-mcp Build a customer support system with order tracking and escalation"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ateam-mcp
Give any AI the ability to build, validate, and deploy production multi-agent systems.
This is an MCP server that connects AI assistants — ChatGPT, Claude, Gemini, Copilot, Cursor, Windsurf, and any MCP-compatible environment — directly to the ADAS platform.
An AI developer says "Build me a customer support system with order tracking and escalation" — and their AI assistant handles the entire lifecycle: reads the spec, builds skill definitions, validates them, deploys to production, and verifies health. No manual JSON authoring, no docs reading, no copy-paste workflows.
Why this matters
Today, building multi-agent systems requires deep platform knowledge, manual configuration, and switching between docs, editors, and dashboards. ateam-mcp eliminates all of that by making the ADAS platform a native capability of the AI tools developers already use.
The AI assistant becomes the developer interface:
Developer: "Create an identity verification agent that checks documents,
validates faces, and escalates fraud cases"
AI Assistant:
→ reads ADAS spec (adas_get_spec)
→ studies working examples (adas_get_examples)
→ builds skill + solution definitions
→ validates iteratively (adas_validate_skill, adas_validate_solution)
→ deploys to production (adas_deploy_solution)
→ verifies everything is running (adas_get_solution → health)
Developer: "Add a new skill that handles address verification"
AI Assistant:
→ deploys into the existing solution (adas_deploy_skill)
→ redeploys (adas_redeploy)
→ confirms healthNo context switching. No manual steps. The full ADAS platform — specs, validation, deployment, monitoring — is available as natural language.
Related MCP server: opsenes-mcp
How it reaches the AI community
ChatGPT users
ChatGPT supports MCP connectors in Developer Mode. Users connect by pasting a single URL:
Settings → Connectors → Developer Mode → paste https://mcp.ateam-ai.com
That's it. All 12 ADAS tools appear in ChatGPT. Any ChatGPT Pro, Plus, Business, or Enterprise user can build and deploy multi-agent solutions through conversation.
Claude users
claude.ai and Claude Desktop — add the hosted connector: open Customize > Connectors (Claude Desktop: Customize in the sidebar, then Connectors), click Add custom connector, enter https://mcp.ateam-ai.com, and click Connect. The A-Team sign-in page opens in the browser and asks for your workspace's key: copy it from app.ateam-ai.com/connect (a workspace owner or admin) and paste it there. The key decides the workspace; to switch, Disconnect and Connect again with the other workspace's key.
Claude Code — the hosted connector, signed in the same way:
claude mcp add --transport http ateam https://mcp.ateam-ai.comthen /mcp and authenticate in the browser.
Never paste a key into a chat. ateam_bootstrap's session field says which workspace a session is on and how to switch.
Cursor / Windsurf / VS Code (Copilot)
Add the hosted server to .cursor/mcp.json, mcp_config.json, or .vscode/mcp.json:
{
"mcpServers": {
"ateam": { "url": "https://mcp.ateam-ai.com/mcp" }
}
}A client with OAuth opens the A-Team sign-in page; one without sends the key as Authorization: Bearer <key> from its own config (see below). A local process (npx -y @ateam-ai/mcp) signs in only through ateam_auth: an ADAS_API_KEY in its environment does not sign it in.
Gemini and other platforms
As MCP adoption grows (it's now governed by the Agentic AI Foundation under the Linux Foundation, co-founded by Anthropic, OpenAI, and Block), every AI platform that implements MCP gets access to ateam-mcp automatically. The remote HTTP endpoint (https://mcp.ateam-ai.com, also at /mcp) works with any client that supports Streamable HTTP transport.
The HTTP endpoint needs a credential on every request: OAuth (clients that support it follow the 401 challenge on their own), or your A-Team API key sent as Authorization: Bearer <key>. An anonymous request is refused with 401; since 0.4.93 there is no anonymous session to call ateam_auth from. See CHANGELOG.md.
Discovery
Developers find ateam-mcp through:
npm —
npm search mcp ai-agents→@ateam-ai/mcpOfficial MCP Registry — registry.modelcontextprotocol.io
Claude Desktop Extensions — built-in extension browser
Claude Code Plugin Marketplace —
/plugin→ Discover tabWindsurf MCP Marketplace — built-in marketplace
VS Code MCP Gallery — Extensions view
Community directories — Smithery, mcp.so, PulseMCP (30,000+ combined listings)
Available tools
Tool | What it does |
| Read the ADAS specification — skill schema, solution architecture, enums, agent guides |
| Get complete working examples — skills, connectors, solutions |
| Validate a skill definition through the 5-stage pipeline |
| Validate a solution — cross-skill contracts + quality scoring |
| Deploy a complete solution to production |
| Add a skill to an existing solution |
| Deploy a connector to ADAS Core |
| List all deployed solutions |
| Inspect a solution — definition, skills, health, status, export |
| Update a solution or skill incrementally (PATCH) |
| Push changes live — regenerates MCP servers, deploys to ADAS Core |
| Talk to the Solution Bot for guided modifications |
| For a chat agent with no shell: open one private workspace (files in |
| Run one command in the workspace (100 s foreground; |
| Check the workspace: unsaved changes, a long save or background command |
| Make the workspace's work live (the only way the other tools see it) |
| Finish; optionally save first. Brings back the single-file write tools withheld while it was open |
The ateam_workspace_* tools are listed whenever you are signed in. A workspace the platform cannot give (a trial workspace, a key tied to no person) is refused by the call itself, with the single-file tools to use instead.
Setup
# Clone
git clone https://github.com/ariekogan/ateam-mcp.git
cd ateam-mcp
# Install
npm install
# Run (a local stdio process)
npm startA local process signs in with ateam_auth, given a workspace key the agent reads from a file outside the chat; an ADAS_API_KEY in the environment does not sign it in and is never sent. ADAS_API_URL in its environment points it at a self-hosted API. Most people use the hosted connector instead (above).
Architecture
┌─────────────────────────────────────────────┐
│ AI Environment │
│ (ChatGPT / Claude / Cursor / Windsurf) │
│ │
│ Developer: "build me a support system" │
└──────────────────┬──────────────────────────┘
│ MCP protocol
│ (stdio or HTTP)
┌──────────────────▼──────────────────────────┐
│ ateam-mcp │
│ 12 tools — spec, validate, deploy, manage │
└──────────────────┬──────────────────────────┘
│ HTTPS
│ X-ADAS-TENANT / X-API-KEY
┌──────────────────▼──────────────────────────┐
│ ADAS External Agent API │
│ api.ateam-ai.com │
└──────────────────┬──────────────────────────┘
│
┌──────────────────▼──────────────────────────┐
│ ADAS Core │
│ Multi-agent runtime │
└─────────────────────────────────────────────┘License
MIT
Available Tools
41 toolsateam_authAInspect
Authenticate with A-Team. Required before any tenant-aware operation (reading solutions, deploying, testing, etc.). The user can get their API key at https://mcp.ateam-ai.com/get-api-key. Only global endpoints (spec, examples, validate) work without auth. IMPORTANT: Even if environment variables (ADAS_API_KEY) are configured, you MUST call ateam_auth explicitly — env vars alone are not sufficient. For cross-tenant admin operations, use master_key instead of api_key.
Inputs: api_key, master_key, tenant, url.
ateam_bootstrapAInspect
REQUIRED onboarding entrypoint for A-Team MCP. MUST be called when user greets, says hi, asks what this is, asks for help, explores capabilities, or when MCP is first connected. Returns platform explanation, example solutions, and assistant behavior instructions. Do NOT improvise an introduction — call this tool instead.
Inputs: no named parameters.
ateam_build_and_runAInspect
DEPLOY THE CURRENT MAIN BRANCH TO A-TEAM CORE. ⚠️ HEAVIEST OPERATION (60-180s): validates solution+skills → deploys all connectors+skills to Core (regenerates MCP servers) → health-checks → optionally runs a warm test → auto-pushes to GitHub.
🌳 DEV/PROD WORKFLOW:
Edit files → ateam_github_patch (writes to
devbranch by default)(Optional) Preview what's about to ship → ateam_github_diff
Ship dev → main → ateam_github_promote (merges + auto-tags
prod-YYYY-MM-DD-NNN)Deploy main to Core → ateam_build_and_run
This tool ALWAYS deploys the main branch — there is no ref parameter. To deploy in-progress dev work, first promote it.
AUTO-DETECTS GitHub repo: if you omit mcp_store and a repo exists, connector code is pulled from main automatically. First deploy requires mcp_store. After that, edit via ateam_github_patch + promote, then build_and_run. For small changes prefer ateam_patch (faster, incremental). Requires authentication.
Inputs: solution_id, solution, skills, connectors, +4 more.
ateam_conversationAInspect
Send a message to a deployed solution and get the result. No skill_id needed — the system auto-routes to the right skill. Supports multi-turn conversations: pass the actor_id from a previous response to continue the thread (e.g., reply to a confirmation prompt). Each call creates a new job but the same actor_id maintains conversation context.
Inputs: solution_id (required), message (required), actor_id, wait, +1 more.
ateam_create_connectorAInspect
Scaffold a new MCP connector with server.js + package.json + README. Eliminates ~50% of identical boilerplate (MCP server setup, tool registration, stdio transport). You then fill in the tool implementations. Set ui_capable=true to include ui.listPlugins / ui.getPlugin stubs (plugin source files added separately via ateam_create_plugin). After scaffolding, the files are uploaded to Core via the same path as ateam_upload_connector.
Inputs: solution_id (required), connector_id (required), name, ui_capable.
ateam_create_pluginAInspect
Scaffold a UI plugin (iframe HTML, React Native TSX, or both) inside an existing connector. Eliminates ~50% of identical plugin boilerplate (imports, theme/bridge hooks, postMessage protocol, default export shape). You then fill in the component body. Use kind='iframe' for web-only, 'rn' for mobile-only, 'adaptive' for both. Auto-discovery (Phase 5 of the strip) picks up the new plugin at next deploy without a manifest declaration.
Inputs: solution_id (required), connector_id (required), plugin_name (required), kind.
ateam_delete_connectorAInspect
Remove a connector from a deployed solution. Stops and deletes it from A-Team Core, removes references from the solution definition (grants, platform_connectors) and skill definitions (connectors array), and cleans up mcp-store files.
Inputs: solution_id (required), connector_id (required).
ateam_delete_skillAInspect
Delete a single skill from a deployed solution. Removes the skill from A-Team Core (kills the running MCP process, unregisters from skill registry, deletes from Mongo), removes the skill from solution.skills[] and solution.linked_skills, and deletes the skill's files from Builder FS. Use this to drop a skill without tearing down the whole solution.
Inputs: solution_id (required), skill_id (required).
ateam_delete_solutionAInspect
Delete a deployed solution and all its skills from A-Team. Use with caution — this removes the solution from both the Skill Builder and A-Team Core. Useful for cleaning up test solutions or starting fresh.
Inputs: solution_id (required).
ateam_get_connector_sourceAInspect
Read the source code files of a deployed MCP connector. Returns all files (server.js, package.json, etc.) stored in the mcp_store for this connector. Use this BEFORE patching or rewriting a connector — always read the current code first so you can make surgical fixes instead of blind full rewrites.
Inputs: solution_id (required), connector_id (required).
ateam_get_examplesAInspect
Get complete working examples that pass validation. Study these before building your own.
Inputs: type (required).
ateam_get_solutionAInspect
Read solution state — definition, skills, health, status, or export. Use this to inspect deployed solutions.
Inputs: solution_id (required), view (required), skill_id.
ateam_get_specAInspect
Get the A-Team specification — schemas, validation rules, system tools, agent guides, and templates. Start here after bootstrap to understand how to build skills and solutions. Use 'section' to get just one part of the skill spec (much smaller than the full spec). Use 'search' to find specific fields or concepts across the spec.
Inputs: topic (required), section, search.
ateam_get_workflowsAInspect
Get the builder workflows — step-by-step state machines for building skills and solutions. Use this to guide users through the entire build process conversationally. Returns phases, what to ask, what to build, exit criteria, and tips for each stage.
Inputs: no named parameters.
ateam_github_diffAInspect
PRE-FLIGHT BEFORE PROMOTE. Compares dev (head) vs main (base) by default — shows exactly which commits and files are about to ship if you call ateam_github_promote() next.
Use this when you want to: • Review changes before promoting to prod • See if dev is ahead of main at all (returns ahead_by: 0 if nothing to promote) • Inspect arbitrary branch/tag/commit comparisons (override base/head)
Inputs: solution_id (required), base, head.
ateam_github_list_versionsAInspect
List all available checkpoints (safe-* tags) for a solution. Shows tag name, date, counter, and commit SHA. Use before rollback to see available safe points.
Inputs: solution_id (required).
ateam_github_logAInspect
View commit history for a solution's GitHub repo. Shows recent commits with messages, SHAs, timestamps, and links. Default reads from main (prod). Pass ref: 'dev' to see in-progress work.
Inputs: solution_id (required), limit, ref.
ateam_github_patchAInspect
Edit a file in the solution's GitHub repo and commit. Two modes:
FULL FILE: provide
content— replaces entire file (good for new files or small files)SEARCH/REPLACE: provide
search+replace— surgical edit without sending full file (preferred for large files like server.js) Always use search/replace for large files (>5KB). Always read the file first with ateam_github_read to get the exact text to search for.
DEFAULTS TO dev BRANCH — writes don't touch prod. Use ateam_github_promote to ship dev→main when ready. Pass ref:'main' only for emergency hotfixes.
Inputs: solution_id (required), path (required), content, search, +3 more.
ateam_github_promoteAInspect
SHIP DEV TO PROD. Merges the dev branch into main and auto-tags the new main HEAD as safe-YYYY-MM-DD-NNN. Use after testing your dev work, when you're ready to deploy changes to production.
Workflow: 1) ateam_github_patch (writes to dev) → 2) ateam_github_promote (merges dev→main) → 3) ateam_build_and_run (deploys main).
Pass dry_run:true to see what's about to ship without merging. On merge conflict the call returns 409 — resolve manually on GitHub (open a PR or use the web UI), then retry.
Inputs: solution_id (required), label, dry_run, skip_tag.
ateam_github_pullAInspect
Deploy a solution FROM its GitHub repo. Reads .ateam/export.json + connector source from the repo and feeds it into the deploy pipeline. Use this to restore a previous version or deploy from GitHub as the source of truth.
Inputs: solution_id (required).
ateam_github_pushAInspect
Push the current deployed solution to GitHub. Auto-creates the repo on first use. Commits the full bundle (solution + skills + connector source) atomically. Use after ateam_build_and_run to version your solution, or anytime you want to snapshot the current state.
Inputs: solution_id (required), message.
ateam_github_readAInspect
Read any file from a solution's GitHub repo. Returns the file content. Use this to read connector source code, skill definitions, or any versioned file. Default reads from main (deployed/prod state). Pass ref: 'dev' to read in-progress work.
Inputs: solution_id (required), path (required), ref.
ateam_github_rollbackAInspect
Roll prod (main branch) back to a previous state.
ADDITIVE — does NOT destroy history. Creates a new commit on top of main whose tree matches the target's tree. The history of everything between target and current main is preserved (you can roll back the rollback).
Workflow: 1) ateam_github_list_versions (find a safe-* tag) → 2) ateam_github_rollback(target: 'safe-...') → 3) ateam_build_and_run (deploys the reverted state).
Inputs: solution_id (required), target (required).
ateam_github_statusAInspect
Check if a solution has a GitHub repo, its URL, and the latest commit. Use this to verify GitHub integration is working for a solution.
Inputs: solution_id (required).
ateam_github_writeAInspect
Write a file to the solution's GitHub repo. Use this to create new connector files or replace existing ones — one file per call. This is the PRIMARY way to write connector code after first deploy. Write each file individually (server.js, package.json, UI assets), then call ateam_github_promote() to ship to prod (dev→main), then ateam_build_and_run() to deploy.
DEFAULTS TO dev BRANCH.
Inputs: solution_id (required), path (required), content (required), message, +1 more.
ateam_list_solutionsAInspect
List all solutions deployed in the Skill Builder.
Inputs: no named parameters.
ateam_patchAInspect
Surgically update ANY field in a skill or solution definition, redeploy, and optionally re-test — all in one step.
SUPPORTED OPERATIONS:
Scalar (dot notation): { "problem.statement": "new value", "role.persona": "You are..." }
Deep nested: { "intents.thresholds.accept": 0.9, "policy.escalation.enabled": true }
Array push: { "tools_push": [{ name: "new_tool", description: "..." }] }
Array delete: { "tools_delete": ["tool_name"] }
Array update: { "tools_update": [{ name: "existing_tool", description: "updated" }] }
Replace whole section: { "role": { persona: "...", goals: [...] } }
EXAMPLES:
Change persona (full replace): updates: { "role.persona": "You are a friendly assistant" }
Append to persona (don't replace): updates: { "persona_append": "\n\nALWAYS respond in 2 sentences." }
Add a guardrail: updates: { "policy.guardrails.never_push": ["Never share passwords"] }
Update problem: updates: { "problem.statement": "...", "problem.goals": ["goal1"] }
Add a tool: updates: { "tools_push": [{ name: "conn.tool", description: "...", inputs: [...], output: {...} }] }
Change intent: updates: { "intents.supported_update": [{ id: "i1", description: "new desc" }] }
Force redeploy: updates: { "_force_redeploy": true }
CREATE a new skill: target='skill', skill_id='my-new-skill', updates: { "problem.statement": "...", "role.persona": "..." } If the skill doesn't exist yet, a default scaffold is created and the updates are applied on top. The skill is automatically added to the solution topology.
Use target='skill' + skill_id for skill fields. Use target='solution' for solution-level fields (linked_skills, platform_connectors, ui_plugins).
Inputs: solution_id (required), target (required), updates (required), skill_id, +1 more.
ateam_redeployAInspect
Re-deploy skills WITHOUT changing any definitions. ⚠️ HEAVY OPERATION: regenerates MCP servers (Python code) for every skill, pushes each to A-Team Core, restarts connectors, and verifies tool discovery. Takes 30-120s depending on skill count. Use after connector restarts, Core hiccups, or stale state. For incremental changes, prefer ateam_patch (which updates + redeploys in one step).
Inputs: solution_id (required), skill_id.
ateam_show_skill_minimalAInspect
Show the minimal authoring view of a skill — persona + connectors + handoff_when + style + policy guardrails only. ~10× smaller than ateam_get_solution(view:'skills') for the same skill. Use this when you only need the irreducible author content (Phase 9 of the strip).
Inputs: solution_id (required), skill_id (required).
ateam_show_solution_minimalAInspect
Show the minimal authoring view of a solution — name + description + style + routing_mode + identity_mode + skill ids + connector ids only. Skips deployed metadata, handoffs (auto-generated), grants, ui_plugins, validation results. Use this for fast inspection without the verbose fields (Phase 9 of the strip).
Inputs: solution_id (required).
ateam_status_allAInspect
Show GitHub sync status for ALL tenants and solutions in one call. Requires master key authentication. Returns a summary table of every tenant's solutions with their GitHub sync state.
Inputs: no named parameters.
ateam_sync_allAInspect
Sync ALL tenants: push Builder FS → GitHub, then pull GitHub → Core MongoDB. Requires master key authentication. Returns a summary table with results for each tenant/solution.
Inputs: push_only, pull_only.
ateam_test_abortAInspect
Abort a running skill test. Stops the job execution at the next iteration boundary. (Advanced.)
Inputs: solution_id (required), skill_id (required), job_id (required).
ateam_test_connectorAInspect
Call a tool on a running connector and get the result. Use this to test individual connector tools (e.g., triggers.list, entities.list, google.command) without deploying to a client. The connector must be connected and running.
Inputs: solution_id (required), connector_id (required), tool (required), args.
ateam_test_notificationAInspect
Fire a REAL notification at an existing actor in a deployed solution — for end-to-end testing of the system-initiated notification path (telegram/push/app channels).
Unlike ateam_test_skill (synthetic test actor with no channels) and ateam_conversation (user-initiated thread), this calls the /api/internal/notify-user path that PCM and other sibling services use — so the actor's real enabled channels actually receive the message.
Use for: • Channel fan-out smoke (does telegram/push/app actually receive it?) • Delivery-result verification (per-channel ok/failed in the response).
Auth: forwards your authed api_key to Core (no master-secret involvement). Tenant is pinned by the key itself — cross-tenant targeting is structurally impossible.
⚠️ SAFETY: • The text is prefixed with [TEST] in the actual notification — visible to the user, anti-phishing. • Rate-limited: 10 calls/min per session. • Every call is audited (caller, tenant, actor, content hash) regardless of outcome. • actor_id is scoped to your tenant — cross-tenant targeting is rejected by Core's per-tenant Mongo isolation. • reply_handler is NOT supported via api-key auth (Core ignores it). Routing the user's next reply to an arbitrary skill is a privilege-escalation surface. For routing/engagement tests, use ateam_test_skill.
Inputs: solution_id (required), actor_id (required), content (required), urgency, +2 more.
ateam_test_pipelineAInspect
Test the decision pipeline (intent detection → planning) for a skill WITHOUT executing tools. Returns intent classification, first planned action, and timing. Use this to debug why a skill classifies intent incorrectly or plans the wrong action.
Inputs: solution_id (required), skill_id (required), message (required).
ateam_test_skillAInspect
Send a test message to a deployed skill and get the full execution result. By default waits for completion (up to 60s). Set wait=false for async mode — returns job_id immediately, then poll with ateam_test_status.
Inputs: solution_id (required), skill_id (required), message (required), wait, +1 more.
ateam_test_statusAInspect
Poll the progress of an async skill test. Returns iteration count, tool call steps, status (running/completed/failed), and result when done. (Advanced — use ateam_test_skill with wait=true for synchronous testing.)
Inputs: solution_id (required), skill_id (required), job_id (required).
ateam_test_voiceAInspect
Simulate a voice conversation with a deployed solution. Runs the full voice pipeline (session → caller verification → prompt → skill dispatch → response) using text instead of audio. Returns each turn with bot response, verification status, tool calls, and entities. Use this to test voice-enabled solutions end-to-end without making a phone call.
Inputs: solution_id (required), messages (required), phone_number, skill_slug, +1 more.
ateam_upload_connectorAInspect
Upload connector code to Core and restart — WITHOUT redeploying skills. Use this to update connector source code (server.js, UI assets, plugins) quickly. Set github=true to pull files from the solution's GitHub repo, or pass files directly. Much faster than ateam_build_and_run for connector-only changes.
Inputs: solution_id (required), connector_id (required), github, files.
ateam_verify_consistencyAInspect
Check that the Builder filesystem state and GitHub state are in sync for a solution. Read-only probe — does NOT trigger a deploy.
Returns: • ok: true + drifts: [] if everything matches • ok: false + drifts: [{path, kind}] listing files that differ (kinds: fs_missing, gh_missing, content_differs)
Drift can creep in when GitHub writes happen but Builder FS doesn't get the mirror update (network blip, container restart mid-write). Boot sync heals most of it on next backend restart; this tool surfaces drift earlier.
Run after a series of ateam_github_patch calls to confirm the Builder backend is consistent with GitHub before you ateam_build_and_run.
Inputs: solution_id (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 41 tools
Each tool targets a distinct purpose. Authentication, onboarding, CRUD for connectors/skills/solutions, various GitHub operations (patch, promote, push, pull, rollback), and multiple testing modes (skill, connector, notification, voice, pipeline) are all clearly separated. No two tools perform the same function, and descriptions are detailed enough to differentiate similar operations like ateam_build_and_run vs ateam_redeploy.
All tools share the ateam_ prefix and most follow a verb_noun pattern (e.g., ateam_create_connector, ateam_test_skill). However, a few tools use noun-only names (ateam_conversation, ateam_get_examples) or compound verbs (ateam_build_and_run), breaking the pattern slightly. Overall, the naming is largely consistent and predictable.
With 41 tools, the server exceeds the typical range of 3-15 tools for a well-scoped server. However, the domain is broad, covering authentication, CRUD, GitHub integration, testing, and admin operations, which justifies many tools. Some consolidation might be possible, but the count is borderline heavy.
The tool surface covers the full lifecycle of solution development: onboarding, authentication, creating/deleting/reading components, comprehensive GitHub operations (diff, log, patch, promote, push, pull, rollback, status), multiple testing modalities (skill, connector, notification, voice, pipeline, abort, status), and admin tools (sync_all, status_all). No obvious gaps are evident.
Maintenance
Related MCP Connectors
Connect your AI assistant to Revensi OS agents, workflows, and business data.
Connect AI assistants to Appimate's Business Agent Tools and Services.
Connect AI assistants to GitHub - manage repos, issues, PRs, and workflows through natural language.
Connect AI assistants to your approved computer for files, commands, browser and desktop tasks.
Related MCP Servers
AlicenseNot gradedqualityFmaintenanceConnects Google Ads, Meta Ads, and LinkedIn Ads to AI assistants, enabling natural language ad campaign management, reporting, and optimization across platforms.MIT
opsenes-mcpofficial
AlicenseNot gradedqualityBmaintenanceConnects AI assistants to the Opsenes platform, exposing its capabilities as MCP tools, resources, and prompts for safe platform operations.MIT- AlicenseNot gradedqualityCmaintenanceConnects AI assistants directly to Azure so users can manage infrastructure, resources, costs, security, and identities through plain-English conversation using their own Entra ID/RBAC permissions.MIT
- FlicenseNot gradedqualityAmaintenanceEnables AI assistants to register identities, send and receive persistent messages, and coordinate across different platforms and sessions using natural language commands.-