@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

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:

export AGENTLED_API_KEY=wsk_...

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 also carries the Codex manifest (.codex-plugin/) and Codex lifecycle hooks — one bundle, both hosts.

Grok Build plugin

The same portable plugin includes a Grok Build manifest at plugins/agentled/.grok-plugin/plugin.json. It starts the published local stdio MCP server declared in .mcp.json; it does not contain an AgentLed API key, OAuth client secret, workspace ID, or customer data. Authenticate with your own AgentLed CLI profile before installing it in Grok Build, then start with read-only tool discovery. Marketplace submission material is in plugins/agentled/GROK_MARKETPLACE_SUBMISSION.md.

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:

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.

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:

{
  "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:

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	Deep-merge updates into a single step by ID
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:

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.

{
  "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):

// 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

update_step 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. Before changing stepInputData.fieldUpdates, pipelineStepPrompt.responseStructure, knowledgeSync.fieldMapping, or any field where keys are user data: call get_step({ workflowId, stepId }) (~1KB), modify locally, send the full new object back via replace[]. This avoids the "patched one key, silently wiped the others" trap.

Diff in the response. Every update_step 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	update_step	updates	Arrays replace wholesale by design. To append, fetch with get_step, splice locally, send the full new array.
stepInputData.fieldUpdates	update_step	get_step → updates (full dict) + replace: ["stepInputData.fieldUpdates"]	Keys are user data; default one-level merge replaces this dict and can drop sibling mappings.
pipelineStepPrompt.responseStructure	update_step	get_step → updates + replace: ["pipelineStepPrompt.responseStructure"]	Output-shape dictionary; treat as user data.
knowledgeSync.fieldMapping	update_step	get_step → updates + replace: ["knowledgeSync.fieldMapping"]	Source→target dict; same trap as fieldUpdates.
renderer.config (when preserving sibling keys matters)	update_step	updates (full renderer.config) + replace: ["renderer.config"]	⚠ replace: ["renderer.config.layout"] does NOT protect renderer.config's siblings — one-level deep-merge runs first on updates.renderer. Replace at the parent level.
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	update_step	unset: ["stepInputData.oldKey"]	Cleanest way to remove. 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.

{
  "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.