> ## Documentation Index
> Fetch the complete documentation index at: https://app.keystroke.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Built-in integrations

> Use built-in OAuth apps and managed integrations.

Keystroke ships a catalog of built-in apps you can connect and use from agents and workflows. A built-in app usually gives you one or both of these:

* **Actions** you can call as workflow steps or agent tools.
* **Credentials** you can connect through the web app or CLI.

Browse the public [integration catalog](/integrations) to find apps and available actions.

## Two built-in paths

Built-in apps currently fall into two broad paths.

| Path                       | Examples                                            | Credential kind | Best for                                                                               |
| -------------------------- | --------------------------------------------------- | --------------- | -------------------------------------------------------------------------------------- |
| **Managed app connection** | Google Workspace, GitHub, Gong, Snowflake, Slackbot | `keystroke`     | OAuth-style catalog apps whose tools run through Keystroke's hosted platform MCP layer |
| **Static API key app**     | Exa                                                 | `api_key`       | Apps where you paste an API key into the credential vault                              |

Some app names overlap with gateway apps. For example, `slackbot` is a managed catalog app for Slack API tools, while the Slack gateway is the native channel integration that lets people talk to an agent in Slack.

## Managed app connections

Managed app connections are the default path for many catalog integrations. In code, generated actions declare a credential for the app. At runtime, Keystroke resolves that credential and routes the tool call through the hosted platform MCP layer. From your workflow or agent, they still look like normal actions: import the generated action from the app package and call `.run()` or attach it as a tool.

<Note>
  Managed catalog apps that use Keystroke's platform MCP layer are a hosted-cloud feature. Local standalone and OSS runtimes do not provide that platform MCP service by default.
</Note>

Connect these apps from the Apps page in the web app. When a connection completes, Keystroke creates credential instances for the selected organization, user, or projects.

## Static API key apps

Some built-in apps use a normal API key. Exa is the common example. Store the key in the credential vault, then use the package's actions or MCP tools.

```bash theme={null}
keystroke credentials set exa --set apiKey=@env:EXA_API_KEY --scope org
```

Then attach the action or tool in code:

```ts theme={null}
import { defineAgent } from "@keystrokehq/keystroke/agent";
import { exaSearch } from "@keystrokehq/exa/actions";

export default defineAgent({
  slug: "researcher",
  systemPrompt: "Use Exa when you need current web research.",
  model: "anthropic/claude-sonnet-4.6",
  tools: [exaSearch],
});
```

The action receives the API key at runtime; the agent only sees the tool interface and result.

## Gateway apps

Gateway apps connect a messaging surface to an agent. Slack is the shipped gateway app today. The connection stores an OAuth credential, and a channel binding decides which agent receives messages from which Slack channel.

Use the agent's channel panel in the web app, or the CLI:

```bash theme={null}
keystroke channels platforms list
keystroke channels accounts --platform slack --project production
keystroke channels bind --agent support --platform slack --account <account-id> --channel <channel-id>
```

See [external channels](/learn/agents/external-channels) for the full Slack workflow.

## Use built-in actions

Built-in actions are normal [actions](/learn/actions/overview). You can use them as [workflow steps](/learn/actions/workflow-steps) or [agent tools](/learn/actions/agent-tools), and their credentials resolve the same way as yours.

```ts theme={null}
// Workflow step
await slackSendMessage.run({ channel, markdown_text });

// Agent tool
tools: [slackSendMessage.scope("user")],
```

Pin a scope when the action should use a user credential or when you need to avoid the default project → organization resolution chain. See [using credentials in code](/learn/credentials/use-credentials).

## Next steps

<CardGroup cols={2}>
  <Card title="Connect and manage apps" href="/learn/credentials/connect-credentials">
    Connect catalog apps and manage their credential instances.
  </Card>

  <Card title="Using credentials in code" href="/learn/credentials/use-credentials">
    Learn how built-in actions resolve credentials at runtime.
  </Card>

  <Card title="Integrations catalog" href="/integrations">
    Browse available apps and actions.
  </Card>

  <Card title="Custom apps and MCP" href="/learn/credentials/custom-integrations">
    Add your own credentials and MCP servers.
  </Card>
</CardGroup>