Agentled MCP

MCPAI代理

提供方 Agentled

AI代理 未标注 无需鉴权 社区 / 第三方 ClaudeCursorWindsurf

专为AI代理设计的自动化引擎,提供长期记忆、100+集成服务和统一信用系统的智能工作流编排

一句话选型结论

按资料字段整理

Agentled MCP 属于AI代理类 MCP 服务器,传输方式未标注,无需鉴权,可直接接入 Claude、Cursor、Windsurf,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类AI代理 传输方式未标注 鉴权无需鉴权 部署方式未标注
GitHub 星标 2 仓库热度,无公开仓库时显示未标注
工具数 55 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

AI代理
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量55暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

AI自动化TypeScript本地部署工作流编排长期记忆多服务集成智能代理

安装与配置

未标注 无需鉴权
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后客户端会列出约 55 个工具,随便调一个只读工具确认能返回结果。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
给代理接外部能力

让代理在任务中途调用搜索、数据库等真实工具。

多步任务编排

把一串操作拆成步骤,由代理按顺序执行。

自动化重复流程

把固定流程交给代理跑,减少手工操作。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 资料标注 55 个工具,覆盖面较广,能满足多种调用。
  • 已适配 Claude、Cursor、Windsurf,换客户端不用重新研究配置。
  • 资料标注无需鉴权,装好就能连。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在AI代理场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Agentled MCP当前 55 未标注 未标注 无 2026-05-17
Filesystem 560c4363 13 未标注 本地部署 无 2026-05-17
Server Everything (everything) 11 stdio · 本地进程 本地部署 有 2026-05-17
Time 7365cb6d 2 SSE · 服务端推送 远程部署 有 2026-05-18
Everything Claude Code 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Openmemory 557e1585 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

AI代理
字段来自项目仓库与公开索引,中文说明由本站标注
提供方Agentled上游标注的维护方 Agentled
分类AI代理本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式无需鉴权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

50.2 KB
来自项目仓库与上游目录的原文,未做删改

@agentled/mcp-server

> The automation engine built for AI agents. Intelligent AI workflow orchestration with long-term memory, 100+ integrations, and unified credits.

What is Agentled?

Agentled is the automation engine built for AI agents.
It gives Claude, Codex, Cursor, Windsurf, and any MCP-compatible client direct access
to intelligent workflow orchestration, long-term memory, and 100+ integrations.

Three things make it different:

🧠 Long-Term Memory — A built-in Knowledge Graph stores insights across
workflow executions. Your agents get smarter over time — they remember past
research, lead scores, content performance, and business context.

⚡ Unified Credits — One API key, one credit system, 100+ services.
No need to sign up for LinkedIn, email, scraping, AI models, or video
generation separately. Connect once, use everything.

🎯 Intelligent Orchestration — AI reasons at every step. Workflows
aren't just "if this then that" — they understand context, make decisions,
and adapt to results.

See it in action```

$ agentled create "Outbound to fintech CTOs in Europe"

Loading workspace context from Knowledge Graph...
✦ ICP loaded ✦ 3 prior campaigns ✦ 847 contacts in KG

Creating campaign with 3 workflows...

━━ Workflow 1: Prospect Research linkedin · hunter · clearbit
✓ LinkedIn: CTO + fintech + EU → 189 profiles
✓ Enriched via Hunter + Clearbit → 156 matched
✓ ICP scoring → 43 high-intent leads

━━ Workflow 2: Signal Detection web-scraper · crunchbase
✓ Job postings → 12 hiring devops
✓ Crunchbase → 8 recently funded
✓ Cross-match: hiring + funded → 5 hot leads

━━ Workflow 3: Outreach email · linkedin · kg
✓ Personalized emails from context
✓ LinkedIn requests with custom notes
✓ 43 leads saved to Knowledge Graph

Campaign saved. Scheduled: every 48h
Credits used: 720
→ https://www.agentled.app/your-team/fintech-cto-outbound


One prompt. Three workflows. LinkedIn enrichment, email finding, AI scoring, multi-channel outreach — all orchestrated, all stored in the Knowledge Graph for the next run.

## Quick Start```bash
claude mcp add --transport stdio --scope user agentled \
  -e AGENTLED_API_KEY=wsk_... \
  -- npx -y @agentled/mcp-server

--scope user registers the server in your user MCP config so it loads in every project (not only the repo where you ran the command). Use a distinct server name (e.g. agentled_my_workspace) if you add multiple workspaces. For team-shared config in git, use --scope project and .mcp.json instead (Claude Code MCP scopes).

Claude Code plugin (one-step install)

Prefer the plugin if you want the MCP server and the Agentled skill installed together. In Claude Code:```
/plugin marketplace add Agentled/mcp-server
/plugin install agentled@agentled


Then set your API key in the shell Claude Code runs from:```bash
export AGENTLED_API_KEY=wsk_...

Codex plugin (one-step install)

The same repository is a Codex marketplace. Install the Agentled plugin with:```bash
codex plugin marketplace add Agentled/mcp-server
codex plugin add agentled@agentled


Then set `AGENTLED_API_KEY=wsk_...` in the shell that launches Codex and start a
new task. The plugin bundles the Agentled skills, starts the MCP server through
`npx -y @agentled/mcp-server`, and loads its lifecycle hooks from the standard
`hooks/hooks.json` path.

The plugin bundles the `agentled` skill (workflow-authoring guidance, namespaced `agentled:agentled`) and auto-starts the MCP server via `npx -y @agentled/mcp-server`. The same plugin directory carries both Claude Code and Codex manifests — one bundle, both hosts.

For Codex, the hook pack acts as in-session guidance around the CLI/MCP loop:
session start explains the Agentled/Codex business-loop split, prompt/tool hooks
add turn-level guidance when client needs, priorities, failures, or product gaps
appear, and stop hooks nudge implementation handoffs to include readiness,
validation, side effects, and next decision. Hooks do not store feedback, call
Agentled APIs, run automations, spend credits, or perform customer/workspace
writes. In Codex, run `/hooks` after installing or changing the plugin so the
local hook definitions are reviewed and trusted before they run.

Use Codex automations for outside-workspace FDE cadence such as Outlook/client
email follow-up, vendor replies, repo/build checks, and weekly operator reviews.
Use Agentled routines for Agentled workspace/runtime checks such as workflow
health, routine health, execution review, workspace summaries, and managed-agent
operations. Use `submit_feedback_to_agentled` or `agentled feedback submit` when
the user explicitly wants product feedback captured.

> **Pick one install path, not both.** If you previously ran `claude mcp add agentled ...` or `--setup-skills`, remove those before (or instead of) installing the plugin — otherwise you get two identical MCP server processes and the skill registered twice. Cleanup: `claude mcp remove agentled` and delete `.claude/skills/agentled/` (or `~/.claude/skills/agentled/`). `--setup-skills` now detects an installed plugin and refuses to double-register unless you pass `--force`.

To develop the plugin locally:```bash
claude --plugin-dir ./plugins/agentled     # load from source
claude plugin validate ./plugins/agentled  # check manifest + structure

> plugins/agentled/skills/ is a generated mirror of skills/ (synced by publish.sh) — edit skills/agentled/SKILL.md, never the mirror.

Local development

Use the local built entrypoint when you want to test unpublished changes against a
local app. npx -y @agentled/mcp-server always uses the latest published npm package.```bash
cd agentled-mcp-server
npm run build

claude mcp add --transport stdio agentled_local \
--env AGENTLED_API_KEY=wsk_... \
--env AGENTLED_URL=http://localhost:8080 \
-- node /absolute/path/to/agentsled-front/agentled-mcp-server/dist/index.js


### Getting your API key

1. Sign up at agentled.app
2. Open **Workspace Settings > Developer**
3. Generate a new API key (starts with `wsk_`)

## Why Agentled MCP?

### One API Key. One Credit System. 100+ Services.

No need to sign up for LinkedIn APIs, email services, web scrapers, video generators, or AI models separately. Agentled handles all integrations through a single credit system.

| Capability | Credits | Without Agentled |
|-----------|---------|-----------------|
| LinkedIn company enrichment | 50 | LinkedIn API ($99/mo+) |
| Email finding & verification | 5 | Hunter.io ($49/mo) |
| AI analysis (Claude/GPT/Gemini) | 10-30 | Multiple API keys + billing |
| Web scraping | 3-10 | Apify account ($49/mo+) |
| Image generation | 30 | DALL-E/Midjourney subscription |
| Video generation (8s scene) | 300 | RunwayML ($15/mo+) |
| Text-to-speech | 60 | ElevenLabs ($22/mo+) |
| Knowledge Graph storage | 1-2 | Custom infrastructure |
| CRM sync (Affinity, HubSpot) | 5-10 | CRM API + middleware |

### Workflows That Learn

Other automation tools start from zero every run. Agentled's Knowledge Graph remembers across executions — what worked, what didn't, what humans corrected. Scoring workflows can use compact row-level `scoring_profile` summaries and bounded scoring-memory retrieval so every run compounds on the last without dumping raw history into prompts.```
Run 1:  Investor scoring → 62% accuracy (cold start)
Run 5:  → 78% (learning from IC feedback)
Run 12: → 89% (compound learning from outcomes, zero manual tuning)

Intelligent Orchestration

Unlike trigger-action tools, Agentled workflows have AI reasoning at every step. Multi-model support (Claude, GPT-4, Gemini, Mistral, DeepSeek, Moonshot), adaptive execution, and human-in-the-loop approval gates when needed.

Agent Teams

Agent Teams let you run multiple AI specialists in a single workflow step. Pick a preset and describe what you need — the team handles coordination, delegation, and synthesis.```
"Add an Agent Team step that researches the company and produces an investment memo"


Six built-in presets cover the most common patterns:

| Preset | What it does |
|--------|-------------|
| `research-and-summarize` | Specialists gather information, one synthesizes a summary |
| `analyze-and-recommend` | Multiple analysts evaluate options, produce a ranked recommendation |
| `generate-then-review` | A generator drafts content, reviewers critique and refine |
| `compare-options` | Specialists argue for competing options, coordinator arbitrates |
| `investigate-in-parallel` | Independent specialists explore different angles simultaneously |
| `review-and-improve` | Reviewers find issues, an editor applies improvements |

When creating Agent Team steps via MCP, include preset metadata so the step opens correctly in the builder:```json
{
  "id": "analyze",
  "type": "agentOrchestrator",
  "name": "Agent Team",
  "orchestratorConfig": {
    "pattern": "supervisor",
    "workers": [
      { "id": "researcher", "name": "Researcher", "systemPrompt": "Research {{input.company_url}} — team, funding, market position" },
      { "id": "analyst", "name": "Analyst", "systemPrompt": "Analyse the research. Identify risks and growth signals." }
    ]
  },
  "metadata": {
    "agentTeamPreset": "research-and-summarize",
    "agentTeamMode": "simple",
    "agentTeamUxVersion": 1
  },
  "next": { "stepId": "milestone" }
}

Existing steps created with raw orchestratorConfig and no metadata continue to work — they open in advanced mode in the builder without errors.

Analytics vs ROI semantics

When describing workflow outcomes, keep these terms separate:

  • pipeline.analyticsConfig = business metrics (execution outcome stats shown in Business Metrics cards/charts).
  • pipeline.metadata.roi = ROI assumptions/rollups (time saved and cost-value estimates).

If you update one without the other, name exactly what changed (e.g. "business metrics configured" vs "ROI assumptions configured").

CLI parity guard

The repository includes an automated parity guard so MCP tool additions do not silently drift from the CLI surface.

  • Test: __tests__/cli/cli-mcp-parity.test.ts
  • Docs: docs/CLI_MCP_PARITY.md

Run it with:```bash
yarn test:node -- cli-mcp-parity.test.ts


## What Can You Build?

### Lead Enrichment & Sales Automation```
"Find fintech CTOs in Europe, enrich via LinkedIn + Hunter, score by ICP fit,
draft personalized outreach, save everything to the Knowledge Graph"

Content & Media Production```

"Scrape trending topics in our niche, generate 5 LinkedIn posts with AI,
create thumbnail images, schedule publishing for the week"


### Company Research & Intelligence```
"Research this company from its URL — team, funding, market position, competitors.
Generate an investment memo. Store in KG for future reference."

VC Investor Matching (real case study)```

"Match this startup against our 2,000+ investor database. Score by sector focus,
stage preference, check size, and portfolio synergy. Compare with last round's outcomes."


3,000+ profiles processed. IC-ready reports. Prediction vs outcome learning — accuracy went from 62% to 89% over 12 runs with zero manual tuning.

## Built-in Skills And Integrations

**Media Production:** Video generation, image generation, text-to-speech, auto-captions, media assembly

**AI Intelligence:** Multi-model AI (Claude, GPT-4, Gemini, Mistral, DeepSeek, Moonshot, xAI), Knowledge Graph, feedback loops, scoring & analytics

**Data & Integration:** LinkedIn (search, enrich, post), email (send, personalize), web scraping, social publishing, CRM sync, document analysis, OCR

## Available Tools

### Use-case operating guides

When work starts from an existing workflow ID, call `get_workflow` first and
inspect `useCaseContext`. Then call `get_use_case` with the returned key or
workflow graph ID, and read any `operatingGuides` before answering
workflow-specific questions, running backfills, or editing live config. Missing
guide warnings mean the operating README is not attached yet and the context is
incomplete.

When work starts from a user's business goal rather than an existing workflow,
use How to Build Use Cases From User Goals.
It covers the external-agent lifecycle from bounded chat result to KG text/list
state, `WorkspaceUseCase`, workflows, approval queues, and home summary updates.

### Workflows

| Tool | Description |
|------|-------------|
| `list_workflows` | List all workflows in the workspace |
| `get_workflow` | Get full workflow definition by ID, including `useCaseContext` when linked |
| `get_workflow_credits` | Get ledger-derived, period-labelled workflow credit usage; opt in to cost drivers with `includeCostDrivers` |
| `create_workflow` | Create a new workflow from pipeline JSON |
| `update_workflow` | Update an existing workflow (top-level scalars; for context/metadata prefer `update_workflow_context`) |
| `update_workflow_context` | Workflow-level analog of `update_step` — three explicit verbs (`updates` / `replace` / `unset`) on `context.*` and `metadata.*` paths, returns `diff` + `warnings` |
| `add_step` | Add a step with automatic positioning and next-pointer rewiring |
| `update_step` | Low-level deep-merge updates into a single step by ID |
| `replace_step_dictionary` | Merge keys into a dictionary path (`fieldUpdates`, `responseStructure`, `fieldMapping`) without dropping siblings |
| `replace_step_path` | Set one nested path while preserving siblings (e.g. `renderer.config.layout`) |
| `unset_step_path` | Delete one step path |
| `append_step_array_item` | Append one item to a step array (`tools`, `integrations`, …) |
| `remove_step_array_item` | Remove one array item by `index` or `match` |
| `remove_step` | Remove a step with automatic next-pointer rewiring |
| `delete_workflow` | Permanently delete a workflow |
| `validate_workflow` | Validate pipeline structure, returns errors per step |
| `publish_workflow` | Change workflow status (draft, live, paused, archived) |
| `export_workflow` | Export a workflow as portable JSON |
| `import_workflow` | Import a workflow from exported JSON |

### Public Form Links

Public form links are the external intake surface for workflows with
`context.executionInputConfig` fields. Use them when people outside the
workspace need to submit a workflow form without signing in: inbound lead
forms, pitch deck submissions, referral forms, support intake, assessment
questionnaires, or any workflow whose first step is a manual/input trigger.

Do **not** use a public form link for internal child workflows. Child workflows
should use `context.executionInputConfig.internal: true` and be called from
another workflow with `agentled.call-workflow`.

| Tool | Description |
|------|-------------|
| `list_public_form_links` | List existing public form links for a workflow |
| `create_public_form_link` | Create and enable a public form link |
| `update_public_form_link` | Enable/disable a link or update limits, expiry, auto-share, and thank-you copy. To revoke external access, set `enabled: false`. |

> **Deletion is intentionally not exposed via the external API or MCP.** To
> revoke a public form link, call `update_public_form_link` with
> `enabled: false`. Permanent deletion requires an authenticated workspace
> member acting through the UI — destructive ops on the form-link surface are
> not granted to the public API key.

Typical agent flow:```text
1. get_workflow({ workflowId })
2. Confirm context.executionInputConfig exists and is not internal.
3. list_public_form_links({ workflowId })
4. If none exists, create_public_form_link({ workflowId, enabled: true })
5. Return the publicUrl to the user.

The public URL is /en/forms/{formLinkId}. On submit, Agentled validates the
form link, starts the workflow with the submitted input, records a
PublicFormSubmission, and increments submissionCount. Optional settings:

  • enabled: disable without deleting the link.
  • expiresAt: ISO datetime expiry.
  • submissionLimit: maximum accepted submissions.
  • autoShare: when true, the public form status page can show generated
    results after completion. Use this only when the workflow output is safe for
    the submitter to see.
  • shareExpiresInDays: expiry for auto-shared result links.
  • successMessage: custom thank-you message after submission.

Internal-only Workflows

Mark a workflow as a child / sub-workflow that is only run via agentled.call-workflow from an orchestrator by setting context.executionInputConfig.internal: true. The UI then hides the Run button and replaces the manual run form with an info banner. Inputs are still validated and passed by orchestrators via executionInputData exactly as before — this is a UI guard, not a runtime restriction.

Use it for any workflow whose goal/description starts with "Internal sub-workflow", that ends in a return step, or that you only intend to invoke from another workflow.```json
{
"context": {
"executionInputConfig": {
"title": "Save Sourced Candidates",
"internal": true,
"fields": [{ "name": "candidates", "label": "Candidates", "type": "text", "required": true }]
}
}
}


Flip the flag via `update_workflow_context` — fetch first, merge locally, replace at the parent level (the merge-order trap from `update_step` applies here too — see `docs/MCP_STEP_EDITING.md`):```jsonc
// 1. get_workflow → read context.executionInputConfig
// 2. local: { ...executionInputConfig, internal: true }
// 3.
{
  "updates": { "context": { "executionInputConfig": {...full merged value...} } },
  "replace": ["context.executionInputConfig"]
}

Editing existing workflows: merge model

Prefer the surgical path tools for common single-path edits — they call get_step when needed and map to the same merge contract:

  • replace_step_dictionary — dictionary key merges (fieldUpdates, responseStructure, fieldMapping)
  • replace_step_path — nested path sets that must preserve siblings
  • unset_step_path — delete one path
  • append_step_array_item / remove_step_array_item — array mutations

Keep raw update_step for complex multi-path edits. It accepts three explicit operations on the same call; at least one must be non-empty.

  • updates — partial step patch, deep-merged ONE LEVEL deep. Top-level scalars are replaced; nested objects (pipelineStepPrompt, stepInputData, etc.) get their direct keys merged with the stored value's keys. Keys nested two levels deep are overwritten as a unit, not merged.
  • replace: string[] — dot-paths whose values from updates are assigned wholesale, skipping the deep-merge. Use this for dictionary-shaped fields where keys are user data (not config) — patching one inner key with updates alone silently wipes the others.
  • unset: string[] — dot-paths to delete. Each path must currently exist on the step (validated against the original).

Read before editing dictionary fields. Prefer replace_step_dictionary. With raw update_step, call get_step({ workflowId, stepId }) (~1KB), modify locally, send the full new object back via replace[].

Diff in the response. Every update_step / surgical-tool call returns diff: { addedPaths, changedPaths, removedPaths } and warnings[]. If the merge silently removed ≥6 fields without an explicit unset, a warning fires.

What to use where:

Path / field API How to edit Notes
name, goal, description, pipelineStepPrompt.template, creditCost update_step updates Plain scalar; safe to send alone.
next, loopConfig, entryConditions (full block) update_step updates Direct nested config; sending the new value wholesale is fine.
tools, integrations surgical / update_step append_step_array_item / remove_step_array_item, or updates with full array Arrays replace wholesale by design.
stepInputData.fieldUpdates surgical replace_step_dictionary Keys are user data; raw one-level merge can drop sibling mappings.
pipelineStepPrompt.responseStructure surgical replace_step_dictionary Output-shape dictionary; treat as user data.
knowledgeSync.fieldMapping surgical replace_step_dictionary Source→target dict; same trap as fieldUpdates.
renderer.config (when preserving sibling keys matters) surgical / update_step replace_step_path on the nested key, or full renderer.config + replace Surgical wrappers replace the owning top-level field safely.
entryConditions.criteria (when preserving the rest of entryConditions) update_step updates: { entryConditions: {...full block...} } Send the full entryConditions block; one-level merge already does the right thing for direct children.
Removing a step input or stale field surgical / update_step unset_step_path or unset: ["stepInputData.oldKey"] Path must exist on the original.
context.inputPages, context.outputPages, context.executionInputConfig update_workflow_context Three explicit verbs (updates / replace / unset) on workflow-relative paths. Compatibility: { contextKey, value } still accepted for wholesale per-key replacement. Workflow-level, not step-level. update_step cannot reach context.* and vice versa.
metadata update_workflow_context Same three verbs on metadata.* paths Workflow-level. Metadata bypasses the draft snapshot — even on live workflows it writes direct to the Pipeline row, immediately.

Executive summaries for workflow groups. When a user asks to save a summary for a workflow, workflow group, cluster, or home card, write it to metadata.executiveSummary with update_workflow_context. Do not store it as Knowledge text unless the user explicitly asks for a reusable note. For a group, write exactly once to the owner pipeline: prefer metadata.workflowGraph.role === "orchestrator", otherwise use the lowest metadata.workflowGraph.order pipeline. Keep the body to 1-2 short sentences, include concrete counts/rates and the reporting period when available, and set author to the active workspace agent, not the external tool/coding agent.```jsonc
{
"workflowId": "2e1cdd60-2fcf-441a-856f-583ae76b38a5",
"updates": {
"metadata": {
"executiveSummary": {
"body": "Startup Outreach sent 46 founder emails for the reporting period, with 28 opens and 9 clicks: a 60.9% open rate, 19.6% click rate, and 32.1% click-to-open rate.",
"bullets": ["Clicks: 6 UTM Pitch Night, 2 plain Pitch Night, 1 calendar."],
"generatedAt": "2026-06-03T00:00:00.000Z",
"author": "AngelHive Assistant"
}
}
}
}


**Type changes.** `step.type` is technically mutable but stale type-specific fields (`pipelineStepPrompt`, `app`, `tools`, `orchestratorConfig`) persist unless you `unset` them. For clean conversions, prefer `remove_step` + `add_step`.

**Live workflows.** Edits are routed to a draft snapshot. Response includes `editingDraft: true`. Inspect via `get_draft`, ship via `promote_draft`, throw away via `discard_draft`. For high-stakes edits, `create_snapshot` first as a manual checkpoint.

**Draft staleness.** When a draft exists, every `update_step` and `get_step` response includes a `draft` summary with `exists`, `draftCreatedAt`, `liveUpdatedAt`, `stale`, `modifiedStepIds`, and `modifiedFields`. If `draft.stale === true`, the live workflow advanced after the draft was created — promoting will land the draft's older values for fields you didn't touch. `update_step` also emits a staleness warning. Recovery: `discard_draft` and re-apply.

⚠ **`discard_draft` only reverts pending context (and step) changes — NOT metadata.** Metadata writes via `update_workflow_context` bypass the draft and apply immediately to the live Pipeline row. If you need a single rollback point covering metadata too, `create_snapshot` before the edit. See `docs/MCP_STEP_EDITING.md` for the full atomicity contract.

**Never** send a full `steps[]` array via `update_workflow`. Use surgical path tools, `update_step`, `add_step`, `remove_step` instead.

For the deep reference (StepMergeError codes, dot-path validation rules, full diff semantics) see `docs/MCP_STEP_EDITING.md`.

### Drafts & Snapshots

| Tool | Description |
|------|-------------|
| `get_draft` | Get the current draft version of a workflow |
| `promote_draft` | Promote a draft to the live version |
| `discard_draft` | Discard the current draft |
| `create_snapshot` | Create a manual config snapshot |
| `delete_snapshot` | Delete a specific config snapshot |
| `list_snapshots` | List version snapshots for a workflow |
| `get_snapshot_content` | Read a snapshot's full config (steps, context, etc.) without restoring it |
| `restore_snapshot` | Restore a workflow to a previous snapshot |

### Executions

| Tool | Description |
|------|-------------|
| `start_workflow` | Start a workflow execution with input. Returns `executionInputId` always and `executionId` only when the async execution row is already available. Pass `useMocks: false` to force a real (credit-consuming) run that ignores per-step mock data; defaults to honoring the workflow's configured mocks. |
| `list_executions` | List executions for a workflow (paginated via `nextToken`), including `pipelineExecutionInputId` for matching a start result that only returned `executionInputId`. |
| `get_execution` | Get execution details with step results. Requires the real `executionId`, not `executionInputId`; if needed, call `list_executions` and match `pipelineExecutionInputId`. |
| `list_timelines` | List step execution records (timelines) for an execution (paginated via `nextToken`) |
| `get_timeline` | Get a single timeline by ID with full step output |
| `stop_execution` | Stop a running execution |
| `retry_execution` | Retry a failed step — auto-detects the most recent failure if no timeline ID provided |
| `rerun` | Rerun or retry any step by `timelineId` — works for failed AND succeeded steps, disambiguates loop iterations |

Run deep links use `////runs?runId=&step=`.
The `step` query param is optional only for run-level handoffs. When a response
points to a specific approval card, output, failure, or current step, include
`&step=` and do not ask the human to open the step manually after a
run-only URL. When present, the app expands that workflow step and scrolls to
it. `stepId` is the workflow step id, not the timeline id. Inside the app
chat/navigation tool surface, `navigateToExecutionPage` accepts the same
`stepId`.

Knowledge row deep links use `///knowledge-and-data/?rowId=`.
The app opens the Knowledge & Data list page and opens the row editor sheet for
that row. The backwards-compatible route
`///knowledge-and-data//row/` redirects to the
canonical query-param URL.

Knowledge text deep links use `///knowledge-and-data/`.
The backwards-compatible route
`///knowledge-and-data/text/` redirects to the canonical
item URL.

### Apps & Testing

| Tool | Description |
|------|-------------|
| `list_apps` | List available apps and integrations |
| `list_connections` | List which app connections are configured |
| `verify_app_connection` | Verify native OAuth health without executing an app action |
| `get_app_actions` | Get action schemas for an app |
| `test_app_action` | Execute one app action in isolation without creating a workflow |
| `test_ai_action` | Test an AI prompt without creating a workflow |
| `test_code_action` | Test JavaScript code in the same sandboxed VM as production |
| `get_step_schema` | Get allowed PipelineStep fields grouped by category |

#### AI step types: `aiAction` vs `aiActionWithTools`

Pick the right type — `validate_workflow` will reject the wrong one:

| You need… | Use |
|-----------|-----|
| Reason over inputs already present in the prompt variables | `aiAction` (single LLM call, no tool loop) |
| Live web search, workspace memory recall/write, knowledge-graph lookup | `aiActionWithTools` with the matching `builtinType` |
| The AI to decide at runtime what inputs to pass to an app action | `aiActionWithTools` with an `appActionConfig` tool |

**`aiActionWithTools` requires at least one tool** — placed under `step.tools` **or** `step.agent.tools` (both are merged at runtime). If you omit tools from both locations, `validate_workflow` returns a blocker `AI_STEP_TOOLS_REQUIRED`. If the prompt says "search the web" / "recall memory" / "knowledge graph" without the matching tool attached, you get a warning `AI_STEP_TOOL_PROMPT_MISMATCH`: web-search prompts need `web_search`; memory prompts need `workspace_memory`; KG lookup prompts need `kg_search` or `kg_traverse`. `fetch_website_content` fetches a known URL and `kg_write` writes KG data, so neither satisfies those lookup/search prompts.

Valid `builtinType` values: `web_search`, `file_search`, `code_interpreter`, `fetch_website_content`, `kg_search`, `kg_traverse`, `kg_nodes`, `kg_write`, `workspace_memory`.

#### Prompt caching for repeated AI steps

Agentled enables provider prompt caching where supported. Caching reuses prompt processing for an identical prefix; it does not cache or replay the AI response. To benefit in bulk workflows, especially scoring/matching loops, write prompts with the stable material first:```text
[stable role and task]
[stable rubric / scoring dimensions]
[stable output JSON schema]
[stable examples or decision rules]

Runtime inputs:
{{currentItem}}
{{steps.previous.output}}
{{input.field}}

Do not start high-volume prompts with INPUTS, {{currentItem}}, {{steps.*}}, {{input.*}}, {{execution.id}}, {{now}}, or {{today}}. Keep changing payloads, dates, execution IDs, and per-item records at the end so OpenAI/Anthropic can cache the shared prefix.```jsonc
// aiActionWithTools example
{
"id": "research",
"type": "aiActionWithTools",
"name": "Research Company",

…(正文过长,页面只展示前面部分,完整内容见仓库)
```

常见问题

6 问
答案由本站依据条目字段整理,不引用上游原文
Agentled MCP 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Agentled MCP 怎么在 Claude、Cursor、Windsurf 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Agentled MCP 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Agentled MCP 需要 API Key 吗?

资料标注为无需认证,装好就能连;如果实际调用时报鉴权错误,按官方文档补上凭据。

Agentled MCP 支持哪些客户端?

资料标注支持 Claude、Cursor、Windsurf;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Agentled MCP 能提供哪些能力?

资料显示约 55 个工具;能力标签包括 AI自动化、TypeScript、Claude。具体工具清单以官方文档为准。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。