# ateam-mcp MCP server

Build, validate, and deploy multi-agent AI solutions from any AI environment.

## Links
- Registry page: https://www.getdrio.com/mcp/io-github-ariekogan-ateam-mcp
- Repository: https://github.com/ariekogan/ateam-mcp

## Install
- Command: `npx -y @ateam-ai/mcp`
- Endpoint: https://mcp.ateam-ai.com/mcp
- Auth: Not captured

## Setup notes
- Package: Npm @ateam-ai/mcp v0.1.2
- Remote endpoint: https://mcp.ateam-ai.com/mcp

## Tools
- ateam_bootstrap - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_auth - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_get_spec - 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.

When designing a persona that orchestrates logic via run_python_script (the Python-as-orchestrator pattern), also fetch topic='python_helpers' — that returns the adas.* helper namespace reference. Skills designed without knowing about adas.* produce 5-10x larger / brittler scripts. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_get_workflows - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_get_examples - Get complete working examples that pass validation. Study these before building your own. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_build_and_run - 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:
  1. Edit files → ateam_github_patch (writes to `dev` branch by default)
  2. (Optional) Preview what's about to ship → ateam_github_diff
  3. Ship dev → main → ateam_github_promote (merges + auto-tags `prod-YYYY-MM-DD-NNN`)
  4. 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_test_skill - Send a test message to a deployed skill and get the execution result.

Wait modes (wait_for):
  • 'root' (default, back-compat) — wait until the message's root job completes, return single-job result. Fast, ignores any sub-skills the root delegated to via askAnySkill.
  • 'chain' — wait until EVERY job in the chain (root + handoffs + askAnySkill subcalls, recursively) reaches a terminal state, then return the full chain tree. Use when testing multi-skill flows (orchestrator → workers, builders → sub-builders, etc.). The response.chain field carries chainJobs[] with parentJobId/relation/depth and executionSteps[] with tool-nesting (opId/parentOpId/_toolDepth).

Legacy: wait:false is equivalent to wait_for:'never' — returns job_id immediately for polling via ateam_test_status. wait:true is the same as the default wait_for:'root'. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_test_notification - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_conversation - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_test_pipeline - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_test_voice - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_patch - Surgically update ANY field in a skill or solution definition, redeploy, and optionally re-test — all in one step.

SUPPORTED OPERATIONS:
1. Scalar (dot notation): { "problem.statement": "new value", "role.persona": "You are..." }
2. Deep nested: { "intents.thresholds.accept": 0.9, "policy.escalation.enabled": true }
3. Array push: { "tools_push": [{ name: "new_tool", description: "..." }] }
4. Array delete: { "tools_delete": ["tool_name"] }
5. Array update: { "tools_update": [{ name: "existing_tool", description: "updated" }] }
6. 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). Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_get_solution - Read solution state — definition, skills, health, status, or export. Use this to inspect deployed solutions. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_list_solutions - List all solutions deployed in the Skill Builder. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_delete_solution - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_delete_skill - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_delete_connector - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_show_skill_minimal - 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). Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_show_solution_minimal - 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). Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_create_connector - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_create_plugin - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_upload_connector - Upload connector code to Core and restart — WITHOUT redeploying skills.

MERGES with the GitHub state at `ref` by default (default ref: 'dev'). Sending a partial file set ONLY overlays those files — the rest of the connector is preserved from GitHub. To fully replace the connector dir (historical behavior), pass replace:true.

Modes:
  • github:true (no files)        — deploy the GitHub state at `ref` as-is.
  • github:true + files:[]        — GitHub state at `ref` as BASE, your files overlay on top (incoming wins).
  • files:[] (no github)          — default MERGE with GitHub state at `ref`. Refuses if no GitHub base exists (no silent nuke).
  • files:[] + replace:true       — full replace. Wipes connector dir + writes only the provided files. Use deliberately.

Common traps this design prevents:
  • Pre-fix bug (2026-06-06): sending just ui-dist HTML wiped server.js + node_modules — connector broke until a full re-upload. Now: those files merge with the GitHub base.
  • Pre-fix bug: github:true silently read from `main` even when patches were on `dev`. Now: defaults to dev; pass ref:'main' to opt into the legacy path. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_test_status - Poll the progress of an async skill test. Returns iteration count, tool call steps, status (running/completed/failed), and result when done.

Set include_chain:true to ALSO include the full chain tree (every job in the chain, rooted at this job_id, with parent/child linkage). Use when this job dispatched askAnySkill subcalls and you want a single snapshot of the whole multi-skill state instead of polling each child job_id separately. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_get_chain - Inspect the full chain tree for any job — rooted at the given job_id, walking down through every handoff and askAnySkill subcall.

Use when a chain has already run and you want to analyze the structure: which skill called which, how deep the call tree went, which tool inside which job invoked which sub-tool. The two main shapes:
  • response.chain.chainJobs[] — one entry per job in the chain. Fields: jobId, skill, status, iteration, depth (0 = root, +1 per askAnySkill subcall hop), relation ('root' | 'subcall' | 'handoff'), parentJobId, parentSkill, goal.
  • response.chain.executionSteps[] — every tool call across all chain jobs, tagged with _skill, _jobId, _depth (= job depth), _relation, _parentSkill, _parentJobId, _toolDepth (tool-in-tool nesting via opId/parentOpId).

Differs from ateam_test_status by purpose: status is for live polling of a job you just kicked off; get_chain is for post-hoc tree analysis (debugging multi-skill flows, regression testing, comparing two runs).

Auth: forwards your authed api_key. Tenant scoped by the key itself. Actor scoping: you can only inspect chains rooted at jobs your actor has access to. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_test_abort - Abort a running skill test. Stops the job execution at the next iteration boundary. (Advanced.) Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_test_connector - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_get_connector_source - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_push - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_pull - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_status - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_read - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_patch - Edit a file in the solution's GitHub repo and commit. Two modes:
1. FULL FILE: provide `content` — replaces entire file (good for new files or small files)
2. 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_write - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_log - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_diff - 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) Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_verify_consistency - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_promote - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_rollback - 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). Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_github_list_versions - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_redeploy - 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). Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_status_all - 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. Endpoint: https://mcp.ateam-ai.com/mcp
- ateam_sync_all - 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. Endpoint: https://mcp.ateam-ai.com/mcp

## Resources
Not captured

## Prompts
Not captured

## Metadata
- Owner: io.github.ariekogan
- Version: 0.1.2
- Runtime: Npm
- Transports: STDIO, HTTP
- License: Not captured
- Language: Not captured
- Stars: Not captured
- Updated: Feb 17, 2026
- Source: https://registry.modelcontextprotocol.io