Integrations

Connect your accounts once and the agent can act in them — read a Slack thread, draft a Gmail reply, open a GitHub PR, update a Notion page, file a Linear issue, or push a HubSpot deal. Aura Workshop reaches 100+ services two ways: direct OAuth for a curated set of first-party providers, and the Composio cloud path for the long tail of ~100 toolkits. Both land connected accounts in the same place, and both turn into tools the agent picks up automatically. Beyond hosted integrations, you can wire in any MCP server — stdio or HTTP — to add tools of your own.

Connecting an account

Everything lives under Settings → Integrations. Each provider shows a Connect button; connecting is a standard OAuth consent flow, so you never paste API keys for supported providers.

1. Click Connect on a provider.
2. Your browser opens that provider's consent screen.
3. Approve the requested scopes.
4. Aura stores the connection and the token auto-injects into any matching skills, MCP servers, and bot listeners.

Disconnecting revokes the token and un-injects it everywhere it was in use. Connections are recorded in the connections table with a source of local or cloud depending on the mode you connected through.

Local vs. Cloud (oauth_mode)

The oauth_mode setting decides how a connection is brokered. Both modes populate the same connections table and feed the same consumers — the difference is where the token lives and how the toolset is exposed.

Pick whichever fits: Local mode keeps credentials entirely on your machine; Cloud mode trades that for far broader coverage without registering apps yourself. You can use both at once — the mode is chosen per connection.

Supported services

The direct-OAuth providers ship with the app and connect fully locally:

The Composio cloud path adds roughly 100 more toolkits across communication, project management, CRM, calendars, knowledge bases, files, and developer tools — the same surface the bundled skills draw on. Toolkits split into managed-OAuth, API-key, and connect-on-demand styles, and Aura picks the right connect flow for each.

How connections become tools

A connection is only useful if the agent can call it. Aura wires each connection into three kinds of consumer, automatically:

• Skills — a skill's YAML frontmatter can declare requires_connection: slack (or any provider id). At run time the framework finds the active connection and injects it — as environment variables for stdio/bash steps or an Authorization: Bearer header for HTTP calls — so the skill just works once the account is connected. See Skills & Agent Tools.
• MCP servers — a server can also declare requires_connection; its tools inherit the injected token. In Cloud mode, connecting a Composio toolkit is mounting an MCP server for that account, so its tools appear in the agent's toolset with no extra config.
• Listeners — bot integrations (Slack, Discord, Telegram, …) resolve their bot token from the connection at start time, and for Composio-managed bots Aura auto-mounts the bot's own toolkit so the agent can act as that bot. See Automation & Workflows.

Background token refresh keeps everything live — direct-OAuth tokens are refreshed shortly before they expire, so long-running agents and schedules don't fall over on an expired token.

MCP servers

Model Context Protocol (MCP) servers extend the agent with tools beyond the built-ins by connecting to external services and data sources. Add and manage them under Settings → MCPs. Aura speaks two transports:

Adding a server

1. Go to Settings → MCPs and click Add MCP Server.
2. Name it and choose the transport.
3. stdio: enter the launch command (e.g. npx) and its arguments, plus any environment variables to pass to the child process.
4. HTTP: enter the server URL and, optionally, OAuth credentials or custom headers (Bearer token, API key, etc.).
5. Pick an isolation mode (see below) and click Connect. A status dot shows connected (green) or disconnected (red).

On connect, tool definitions are cached so they appear instantly in the tool picker without re-querying the server each task. You can also import server configs from JSON (standard MCP schema) to share setups across machines or teammates.

# Add an MCP server (stdio transport)
curl -X POST -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "File System MCP",
    "transport": "stdio",
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"],
    "env": {},
    "isolation": "shared"
  }' \
  http://localhost:18800/api/mcp/servers

# Add an MCP server (HTTP transport with custom auth header)
curl -X POST -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Cloud MCP",
    "transport": "http",
    "url": "https://mcp.example.com/mcp",
    "headers": { "Authorization": "Bearer my-token" },
    "isolation": "per_task"
  }' \
  http://localhost:18800/api/mcp/servers

Isolation modes

Plugins

Installed CLI tools can register as MCP servers without any code changes via a plugin manifest that carries either a stdio command + args or an HTTP URL + transport. Manage these under Settings → Plugins, or programmatically via /api/plugins.

Aura as an MCP server

The relationship runs both ways: Aura Workshop also exposes its own tools as an MCP server at POST /api/mcp/v1, so external MCP clients — such as Claude Code, Cursor, Kiro, Kilo, or Vibe — can call back into Aura. The exposed surface covers the core file and search tools: bash, read_file, write_file, edit_file, glob, grep, list_dir, web_search, and web_fetch.

Point your client's MCP config at your Aura instance's /api/mcp/v1 endpoint and authenticate with your AURA_WEB_TOKEN. For the full endpoint reference, see the API Reference.