Guide

Create a Manus Skill for Email and Calendar with Nylas CLI

Manus Skills turn your agent from a generalist into a specialist. This guide walks through creating a Skill that gives Manus access to your email and calendar using the Nylas CLI as the execution layer. You will write a SKILL.md file, add helper scripts, and configure the Skill so Manus can read your inbox, send messages, search threads, create events, and check availability.

What is Manus?

Manus is an AI agent platform designed for end-to-end task execution, not just chat responses. Instead of only answering questions, Manus can plan multi-step work, use tools, run code in a sandboxed environment, and produce deliverables like reports, analyses, and automations.

For this guide, the key idea is simple: Manus gives you the agent runtime, and Nylas CLI gives the agent email and calendar actions. When you combine that with a Skill, you get reusable behavior you can trigger on demand.

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. They follow the open Agent Skills specification introduced by Anthropic. Each Skill is a folder containing a SKILL.md file (YAML frontmatter + Markdown instructions) and optional directories for scripts, references, and assets.

Skills use progressive disclosure to preserve the agent's context window:

  • 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?

Manus runs in an isolated sandbox with a full Ubuntu environment and shell access. It can browse the web, write code, and manipulate files, but it has no built-in email or calendar access. The Nylas CLI fills that gap. Once installed inside the sandbox, 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.

A Manus Skill wrapping the Nylas CLI gives the agent structured instructions for when and how to use these commands, so it can handle requests like "summarize my unread emails" or "schedule a meeting with Alice next Tuesday at 2pm" reliably.

Requirements

  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

Here is what you will build:

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

Create a file called SKILL.md in a new nylas-cli/ folder. The frontmatter follows the Agent Skills spec:

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

Create scripts/setup.sh inside the same nylas-cli/ folder. This script runs inside the Manus sandbox (Ubuntu-based) when the agent needs to install the CLI for the first time.

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

You have four options for getting the Skill into your Manus workspace:

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

Once installed, activate the Skill by typing /nylas-cli in the Manus chat input. This loads the full SKILL.md instructions into the agent's context. From there, you can make requests in natural language:

  • "Show me my unread emails" - the agent runs nylas email list --unread --limit 20 --json and summarizes the results.
  • "Reply to the email from Sarah about the budget and say I'll have numbers by Friday" - the agent searches for Sarah's email, drafts a reply with nylas email smart-compose, shows you the draft, and sends after confirmation.
  • "Schedule a 30-minute meeting with alice@company.com next Tuesday at 2pm" - the agent uses nylas calendar schedule ai or nylas calendar events create and confirms the result.
  • "Am I free Thursday afternoon?" - the agent checks nylas calendar events list or nylas calendar availability check and reports back.
  • "Find all emails about the Q4 contract and summarize the key decisions" - the agent searches with nylas email search "Q4 contract" --json, reads the results, and summarizes.

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

Combining with other Skills and MCP

One of the strengths of the Skills architecture is composability. You can combine the Nylas CLI Skill with other Skills in the same session. For example:

  • 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, or IMAP.

Security considerations

Before uploading or importing any Skill, review its contents. Manus can audit a Skill for you:

"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

"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

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