Docs/Skills & Workflows

Skills & Workflows

Jarvis SDK has three levels of agent capability: Modules (atomic tools), Skills (composed recipes), and Workflows (multi-step pipelines). Understanding the difference helps you build the right solution.

Modules

A module is a single tool with one or more actions. Modules are the atomic unit of the Jarvis SDK ecosystem — every skill and workflow is built from them.

- Each module has a name, category, and set of actions
- Actions accept typed JSON input and return typed JSON output
- 700+ modules available (83 builtin + 618+ via Composio integrations)
- Execute via POST /api/v1/modules/{name}/execute

Example: Execute a module action

curl -X POST https://jarvissdk.com/api/v1/modules/text-toolkit/execute \
  -H "x-api-key: jsk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"action": "word_count", "input": {"text": "Hello world from Jarvis SDK"}}'

# → { "result": { "count": 5 } }

Skills

A skill is a pre-built composition of multiple modules designed to accomplish a specific task. Think of skills as recipes that combine tools into a single callable unit.

- Combines 2-10 modules into sequential steps
- Output of step N flows as input to step N+1
- Smart defaults — agents can execute with minimal input
- 40+ pre-built skills across 15 categories
- Browse at /skills
- Execute via POST /api/v1/skills/{id}/execute
- Also available as MCP tools: jarvis_skill_{slug}

Example: Execute a skill

curl -X POST https://jarvissdk.com/api/v1/skills/content-publisher/execute \
  -H "x-api-key: jsk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"topic": "AI agent marketplaces", "tone": "professional"}'

# → {
#   "skill_name": "Content Publisher",
#   "status": "completed",
#   "completed_steps": 3,
#   "total_steps": 3,
#   "step_results": [
#     { "module_name": "ai-writer", "action_name": "generate", "status": "completed", ... },
#     { "module_name": "seo-toolkit", "action_name": "optimize", "status": "completed", ... },
#     { "module_name": "markdown-toolkit", "action_name": "format", "status": "completed", ... }
#   ]
# }

Compose API — Build Skills on the Fly

The Compose API lets agents dynamically stack 2-10 existing skills into compound workflows. This is unique to Jarvis SDK — no other platform lets agents compose tools programmatically at runtime.

How it works

1. Send skill IDs in the order you want them executed
2. Step references ({{steps.N.output}}) are auto-reindexed
3. Tags, connections, and default inputs are merged with deduplication
4. Returns a new composed skill you can execute immediately

Compose two skills into one

curl -X POST https://jarvissdk.com/api/v1/skills/compose \
  -H "x-api-key: jsk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Full Content Pipeline",
    "skill_ids": [
      "content-publisher-skill-id",
      "seo-audit-skill-id"
    ],
    "description": "Generate content, then audit it for SEO"
  }'

# → {
#   "composed_skill": {
#     "name": "Full Content Pipeline",
#     "steps": [ ...all steps from both skills, reindexed... ],
#     "tags": [ ...merged, deduplicated... ],
#     "default_inputs": { ...merged from all source skills... }
#   }
# }

Compose API constraints

- Minimum 2 skills, maximum 10 skills per composition
- All referenced skills must exist
- Step references are automatically adjusted — no manual reindexing needed
- Resulting skill can be saved and executed like any other skill

Workflows

A workflow is a multi-step execution pipeline with conditional logic, retries, timeouts, and error handling. Workflows are the most powerful composition layer.

- Steps can be conditional (run step B only if step A succeeds)
- Built-in retry logic and per-step timeout
- Output of step N automatically flows as input to step N+1
- Can be triggered by cron schedules, webhooks, or API calls
- Visual builder at /dashboard/workflows/builder
- Manage via POST /api/v1/workflows

Example: Create and execute a workflow

// Create workflow
curl -X POST https://jarvissdk.com/api/v1/workflows \
  -H "x-api-key: jsk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Daily Digest",
    "steps": [
      {
        "module": "gmail-reader",
        "action": "fetch_unread",
        "input": { "max_results": 10 }
      },
      {
        "module": "ai-analyzer",
        "action": "summarize",
        "input": { "text": "{{steps.0.output}}" }
      },
      {
        "module": "slack-sender",
        "action": "post_message",
        "input": {
          "channel": "#daily-digest",
          "text": "{{steps.1.output}}"
        }
      }
    ],
    "trigger": { "type": "cron", "schedule": "0 9 * * *" }
  }'

// Execute manually
curl -X POST https://jarvissdk.com/api/v1/workflows/{id}/execute \
  -H "x-api-key: jsk_your_key"

Comparison

Feature	Module	Skill	Workflow
Complexity	Single tool	2-10 tools combined	N steps with logic
Data flow	Input → Output	Step output → next step input	Step output → next step input
Conditional logic	No	No	Yes (if/else per step)
Retries	No	No	Per-step configurable
Triggers	API call only	API call + MCP	Cron + Webhook + API
Compose at runtime	N/A	Yes (Compose API)	Yes (Workflow API)
MCP exposure	Individual tools	Single compound tool	Not directly (API only)
Best for	Single operations	Common task patterns	Complex automations

When to Use What

Use a Module

When you need a single operation: hash a string, validate JSON, send an email, generate a UUID. One input, one output, done.

Use a Skill

When you have a repeatable task that always combines the same tools: "generate + optimize + publish content" or "read emails + extract data + update CRM." Skills are also exposed as MCP tools, so agents can use them naturally in conversation.

Use the Compose API

When you want to dynamically combine existing skills at runtime. An agent can inspect available skills, pick the ones it needs, compose them, and execute — all without human intervention. This is the "skills over agents" pattern.

Use a Workflow

When you need conditional branching, error recovery, scheduled execution, or complex multi-step pipelines that run unattended. Workflows are the most powerful but also the most complex composition layer.

Code Examples

Chain tools (REST API)

The chain endpoint runs multiple module actions in sequence, passing output from one to the next:

curl -X POST https://jarvissdk.com/api/v1/chain \
  -H "x-api-key: jsk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "steps": [
      { "module": "text-toolkit", "action": "slugify", "input": {"text": "My Blog Post Title"} },
      { "module": "hash-toolkit", "action": "sha256", "input": {"text": "{{prev.slug}}"} }
    ]
  }'

# Step 1 output: { slug: "my-blog-post-title" }
# Step 2 output: { hash: "a4c5..." }

Batch execution (parallel)

Run multiple independent operations in parallel:

curl -X POST https://jarvissdk.com/api/v1/batch \
  -H "x-api-key: jsk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "operations": [
      { "module": "hash-toolkit", "action": "sha256", "input": {"text": "file1"} },
      { "module": "hash-toolkit", "action": "sha256", "input": {"text": "file2"} },
      { "module": "hash-toolkit", "action": "md5",    "input": {"text": "file3"} }
    ]
  }'

# All 3 operations execute in parallel

Next steps

Browse the Skills Marketplace MCP Integration — use skills as MCP tools REST API Reference Webhooks — trigger workflows from external events

← Billing Webhooks →