Guide

Create a Manus Skill: Email & Calendar Workflow

Create a Manus Skill that installs Nylas CLI in the sandbox and teaches your agent email and calendar workflows. Defines the workflow in SKILL.md, adds setup scripts for inbox and calendar tasks, and works across major providers.

Written by Caleb Geene Director, Site Reliability Engineering

Reviewed by Hazik

Verified — CLI 3.1.1 · Gmail, Outlook · last tested April 11, 2026

What is Manus?

Manus is an AI agent platform designed for end-to-end task execution, not just chat responses. Manus can plan multi-step work, use tools, run code in a sandboxed Ubuntu environment, and produce deliverables like reports, analyses, and automations. According to the Manus documentation, the platform processes over 100,000 tasks per month across its user base.

Manus gives you the agent runtime, and the Nylas CLI gives the agent 72+ email, calendar, and contacts commands across 6 providers. When you combine that with a Skill, you get reusable behavior you can trigger on demand — install takes under 2 minutes and works with Gmail, Outlook, Exchange, Yahoo, iCloud, and IMAP through one authentication step.

What are Manus Skills?

Manus Skills are modular packages of instructions, scripts, and reference files that teach the Manus agent how to perform specialized tasks. Each Skill is a folder containing a SKILL.md file (YAML frontmatter + Markdown instructions) and optional directories for scripts, references, and assets. Skills follow the open Agent Skills specification introduced by Anthropic, which means a single Skill definition can work across any agent platform that supports the standard.

The Manus Skills system uses progressive disclosure to preserve the agent's context window, keeping initial memory overhead to roughly 100 tokens per Skill:

  • Level 1 (metadata): name and description, loaded at startup (~100 tokens)
  • Level 2 (instructions): the full SKILL.md body, loaded when triggered (<5k tokens)
  • Level 3 (resources): scripts and reference files, loaded on demand

This means Manus only reads the full Skill when you activate it with the / slash command, and only pulls in scripts when it needs them.

Why pair Manus with the Nylas CLI?

The Manus sandbox includes a full Ubuntu environment with shell access, web browsing, and file manipulation, but it has no built-in email or calendar access. The Nylas CLI fills that gap by providing 72+ commands that cover 6 email providers through a single binary. Once installed, Manus can run commands like nylas email list, nylas email send, and nylas calendar events create to interact with Gmail, Outlook, or any provider supported by the Nylas API.

Without the Nylas CLI, building equivalent email access for Manus would require writing custom API integrations for each provider — Google requires OAuth 2.0 with 6 scopes for Gmail access alone, and Microsoft Graph requires Azure AD app registration. A Manus Skill wrapping the CLI gives the agent structured instructions for when and how to use these commands, so the agent can handle requests like "summarize my unread emails" or "schedule a meeting with Alice next Tuesday at 2pm" reliably.

Requirements

Building a Manus Skill with Nylas CLI requires three things: a Manus account, a Nylas account with an API key, and basic terminal familiarity. Setup takes under 5 minutes if you already have both accounts. The Manus free plan includes limited monthly credits, and the Nylas free tier covers development and testing with no card required.

  1. A Manus account. Manus offers a free plan with limited monthly credits. Paid plans (starting at $20/month) provide full access to all features. Check the pricing page for current plan details on Skills availability. Complex tasks (email searches, multi-step workflows) consume more credits than simple prompts.
  2. A Nylas account. Sign up at dashboard-v3.nylas.com. You need an API key and at least one connected grant (mailbox). The free tier covers development and testing.
  3. Familiarity with the terminal. The Skill includes shell scripts that the Manus agent executes in its sandbox. You do not need to be a developer, but you should be comfortable reading shell commands.

Skill directory structure

A Manus Skill requires exactly 2 files: a SKILL.md that defines metadata and agent instructions, and a setup script that handles installation. The Agent Skills specification requires the SKILL.md to sit at the root of the Skill folder, with any supporting scripts in a scripts/ subdirectory. This minimal structure keeps the Skill under 5 KB total.

nylas-cli/
├── SKILL.md              # Instructions and metadata
└── scripts/
    └── setup.sh          # Installs and authenticates the Nylas CLI

The SKILL.md file contains everything the agent needs to understand what the Skill does and how to use it. The scripts/setup.sh file handles installation and authentication inside the Manus sandbox so the agent can run it once at the start of a session.

Write the SKILL.md

The SKILL.md file is the core of any Manus Skill. It combines YAML frontmatter (name, description, compatibility) with Markdown instructions that the agent reads when the Skill is activated. According to the Agent Skills spec, the frontmatter fields name and description are required, while compatibility and metadata are optional but recommended.

Create a file called SKILL.md in a new nylas-cli/ folder. The description field is what Manus displays in the Skills menu and uses to decide when to suggest the Skill, so it should list the key capabilities in plain language. The full file runs about 80 lines and covers 12 CLI commands:

---
name: nylas-cli
description: >
  Read, send, and search email. Create, update, and list calendar events.
  Check availability and find meeting times. Uses the Nylas CLI as the
  execution layer. Activate when the user asks about email, inbox, messages,
  calendar, events, scheduling, or availability.
compatibility: Requires internet access and a Nylas API key.
metadata:
  author: nylas
  version: "1.0"
---

# Nylas CLI

This skill gives you access to email and calendar through the Nylas CLI.

## First-time setup

If `nylas` is not available, run the setup script:

```bash
bash scripts/setup.sh
```

The script installs the CLI and prompts for a Nylas API key. After setup,
verify with:

```bash
nylas auth whoami
```

## Email commands

### List recent messages
```bash
nylas email list --limit 20 --json
```

### List unread messages only
```bash
nylas email list --unread --limit 20 --json
```

### Search by keyword
```bash
nylas email search "quarterly report" --limit 10 --json
```

### Read a specific message
```bash
nylas email read MESSAGE_ID --json
```

### Send an email
```bash
nylas email send --to "recipient@example.com" --subject "Subject" --body "Body text" --yes
```

Always confirm recipient and content with the user before sending.
The `--yes` flag skips the interactive confirmation prompt, which would
hang in a non-interactive environment.

### AI-powered compose
```bash
nylas email smart-compose --prompt "Draft a polite follow-up about the Q4 budget"
```

## Calendar commands

### List upcoming events
```bash
nylas calendar events list --days 7 --json
```

### Create an event
```bash
nylas calendar events create --title "Team sync" --start "2026-02-20 14:00" --end "2026-02-20 14:30"
```

### Natural language scheduling
```bash
nylas calendar schedule ai "30-minute meeting with alice@company.com next Tuesday at 2pm"
```

### Check availability
```bash
nylas calendar availability check
```

### Find a mutual meeting time
```bash
nylas calendar find-time --participants alice@company.com --duration 30m
```

## Important rules

- Always use `--json` when you need to parse output or extract specific fields.
- Always use `--yes` when sending email to avoid hanging on prompts.
- Never send email without confirming recipient, subject, and body with the user.
- If a command fails with an auth error, re-run `scripts/setup.sh`.

Write the setup script

The setup script installs the Nylas CLI binary and configures authentication inside the Manus sandbox. The script detects the CPU architecture (amd64 or arm64), downloads the latest release from GitHub, and verifies the binary is executable — the entire process takes under 30 seconds on a typical sandbox connection.

Create scripts/setup.sh inside the same nylas-cli/ folder. The script uses set -euo pipefail for strict error handling: any failed command, undefined variable, or pipe error causes immediate exit rather than silent failure. The Manus sandbox runs Ubuntu, so the script targets Linux binaries specifically:

#!/usr/bin/env bash
set -euo pipefail

NYLAS_BIN="nylas"

if command -v nylas &>/dev/null; then
  echo "Nylas CLI is already installed: $(nylas --version)"
else
  echo "Installing Nylas CLI..."

  ARCH="$(uname -m)"
  case "$ARCH" in
    x86_64|amd64) ARCH="amd64" ;;
    aarch64|arm64) ARCH="arm64" ;;
    *) echo "Unsupported architecture: $ARCH" >&2; exit 1 ;;
  esac

  TAG="$(curl -fsSL https://api.github.com/repos/nylas/cli/releases/latest | sed -n 's/.*"tag_name":[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)"
  VERSION="${TAG#v}"
  URL="https://github.com/nylas/cli/releases/download/${TAG}/nylas_${VERSION}_linux_${ARCH}.tar.gz"

  INSTALL_DIR="/usr/local/bin"
  if [ ! -w "$INSTALL_DIR" ]; then
    INSTALL_DIR="$HOME/.local/bin"
    mkdir -p "$INSTALL_DIR"
    export PATH="$INSTALL_DIR:$PATH"
  fi

  curl -fsSL "$URL" | tar -xz -C "$INSTALL_DIR" nylas
  chmod +x "$INSTALL_DIR/nylas"
  NYLAS_BIN="$INSTALL_DIR/nylas"
  echo "Installed: $($NYLAS_BIN --version)"
fi

if ! command -v "$NYLAS_BIN" &>/dev/null && [ -x "$HOME/.local/bin/nylas" ]; then
  NYLAS_BIN="$HOME/.local/bin/nylas"
fi

# Check if already authenticated
if "$NYLAS_BIN" auth whoami &>/dev/null; then
  echo "Already authenticated."
  "$NYLAS_BIN" auth whoami
else
  echo "Not authenticated. Running nylas auth config..."
  echo "You will need your Nylas API key from https://dashboard-v3.nylas.com"
  "$NYLAS_BIN" auth config
fi

The script downloads the latest Linux release from GitHub using the current tag, then installs it to /usr/local/bin (or ~/.local/bin if needed). This avoids assuming Go is pre-installed. The key requirement is that nylas is installed and authenticated before the agent tries to run email or calendar commands.

Add the Skill to Manus

Manus supports 4 methods for importing Skills into a workspace: direct folder upload, GitHub import, agent-assisted packaging, and the official library. The upload method is the fastest — it takes under 10 seconds once the folder is ready. Manus reads the SKILL.md frontmatter automatically and registers the Skill name, description, and compatibility requirements.

Option A: Upload the folder (simplest)

  1. Open Manus and go to the Skills tab in the left sidebar.
  2. Click + Add and choose Upload a skill.
  3. Select the nylas-cli/ folder (or zip it first). Manus reads the SKILL.md frontmatter and registers the Skill.

Option B: Import from GitHub

If you push the nylas-cli/ folder to a GitHub repository, you can import it directly:

  1. In the Skills tab, click + Add and choose Import from GitHub.
  2. Paste the repository URL. Manus clones the repo and finds the SKILL.md.

Option C: Build with Manus

If you already have a successful session where Manus used the Nylas CLI, you can ask Manus to package it as a Skill. Say something like: "Package this workflow as a reusable Skill called nylas-cli." Manus will generate the SKILL.md and any supporting files automatically.

Option D: Add from official library

Check the official Manus Skills library (accessible from the + Add menu) to see if a Nylas Skill is already available. The official library is maintained by the Manus team and includes pre-built Skills for common workflows.

Use the Skill in a conversation

Activating the Nylas CLI Skill loads the full SKILL.md instructions into the Manus agent's context, giving the agent access to 12 email and calendar commands. Type /nylas-cli in the Manus chat input to activate. The agent then maps natural language requests to the appropriate CLI commands, handles JSON parsing, and presents results in readable form. A typical email list request completes in 3-5 seconds.

The agent handles the Nylas CLI commands behind the scenes. You interact purely through natural language.

Combining with other Skills and MCP

The Manus Skills architecture supports composability, meaning multiple Skills can run in the same agent session and share context. Combining the Nylas CLI Skill with a data analysis or content creation Skill lets Manus chain email retrieval, data processing, and output generation into a single workflow. Each Skill adds roughly 100 tokens of overhead at startup and under 5,000 tokens when fully activated.

  • Nylas + Data Analysis Skill: "Pull all invoices from my inbox this month and create a spending summary spreadsheet."
  • Nylas + Content Creation Skill: "Draft a newsletter email based on our latest blog post and send it to the marketing list."
  • Nylas + Research Skill: "Research the attendees for tomorrow's meeting and prepare a briefing document."

If you already use Manus MCP connectors (for example, Gmail or Google Calendar), Skills and MCP are complementary. MCP provides standardized data pipelines, while Skills provide the procedural instructions for using them. The Nylas CLI Skill adds provider-agnostic email and calendar access through a single interface, regardless of whether your mailbox is Gmail, Outlook, Exchange, Yahoo, iCloud, or IMAP.

Security considerations

Every Manus Skill runs inside an isolated virtual machine that is destroyed after the session ends. This means credentials stored during setup do not persist across sessions — the agent must re-authenticate each time. However, you should still review any Skill before importing it, since the agent executes scripts with full shell access inside the sandbox.

Manus can audit a Skill for you. Paste the prompt below into the Manus chat to have the agent analyze both files and report any security concerns before you activate the Skill:

"Review the Skill named nylas-cli. Analyze its SKILL.md file and
scripts/setup.sh. Explain what it does, identify any potential security
risks, and tell me if it's safe to use."

Key things to check:

  • API key handling: The setup script uses nylas auth config, which stores credentials locally in the sandbox. Credentials are not embedded in the Skill files themselves.
  • Send confirmation: The SKILL.md instructions tell the agent to confirm before sending email. If you share this Skill with others, they inherit that safeguard.
  • Sandbox isolation: Manus runs each task in an isolated virtual machine. The Nylas CLI and its credentials exist only within that sandbox session.

Troubleshooting

Most Skill issues fall into 4 categories: missing binary, expired authentication, Skill registration errors, and interactive prompt hangs. The fixes are straightforward — re-running the setup script resolves about 80% of problems. Each issue and its solution is listed with the exact commands the Manus agent needs.

"nylas: command not found"

The setup script has not run yet. Ask Manus to run bash scripts/setup.sh. If the binary was installed but is not on the PATH, run export PATH="$PATH:/usr/local/bin:$HOME/.local/bin" in the sandbox.

Authentication errors

The API key may be missing or expired. Ask Manus to run nylas auth config and provide a fresh API key from dashboard-v3.nylas.com. Then verify with nylas auth whoami.

Skill does not appear in the slash menu

Check the Skills tab to confirm the Skill was uploaded. The name field in the SKILL.md frontmatter must be lowercase, contain only letters, numbers, and hyphens, and match the folder name. If you renamed the folder after upload, re-upload.

Running out of credits

Each Nylas CLI command the agent runs counts toward your Manus credit usage. Complex tasks that involve multiple email searches and sends will consume more credits than simple queries. Tips for reducing usage:

  • Be specific in your requests ("find emails from Sarah this week" vs "find emails")
  • Batch related requests into a single prompt
  • Use --limit in the Skill instructions to cap the number of results

Commands hang or time out

Interactive prompts cause hangs in the Manus sandbox. The SKILL.md instructions include --yes for sends and --json for output. If a different command is hanging, it may be waiting for input. Check the command's documentation at cli.nylas.com/docs/commands for any interactive flags you need to bypass.

FAQ

Common questions about Manus Skills, pricing, provider support, and the relationship between Skills and MCP. The Nylas CLI Skill works with any email provider that the Nylas platform supports — currently 6 providers covering over 90% of business email accounts worldwide.

Does this cost money?

Manus has a free plan with limited monthly credits. Paid plans start at $20/month with more credits and full feature access. Check the pricing page for current details on which plans include Skills. The Nylas API also has a free tier for development and testing. For production workloads with high volume, both Manus and Nylas have paid tiers.

Can I use this Skill with other AI agents?

The SKILL.md format follows the open Agent Skills specification. Any agent that supports this standard can use the same Skill. The Manus-specific parts are the sandbox environment and the / activation command.

What is the difference between a Skill and MCP?

MCP (Model Context Protocol) creates standardized data pipelines between the agent and external services. Skills provide the procedural instructions for how and when to use those pipelines. They are complementary. You can use both a Manus MCP connector and the Nylas CLI Skill in the same session.

Can I edit the Skill after creating it?

Yes. Skills are file-based. Download the Skill, edit the SKILL.md or scripts, and re-upload. Or edit directly in the Manus Skills management interface.

Can I share the Skill with my team?

Push the Skill folder to a GitHub repository and share the link. Team members can import it from the Skills tab. Manus also supports Project Skills, which lets team administrators curate and share Skills at the project level.

Which email providers are supported?

The Nylas platform supports Gmail, Outlook (Microsoft 365 and Exchange), Yahoo, and IMAP-compatible providers. In the CLI, use nylas auth login for direct Google/Microsoft OAuth flows, or use nylas auth config with an API key for connected grants from the Nylas dashboard.

Next steps

The Nylas CLI Skill covers email and calendar commands, but Manus and the CLI can do more. The guides and resources listed here cover MCP integration, provider-specific workflows, AI scheduling, and the full command reference with all 72+ flags and subcommands.