> ## Documentation Index
> Fetch the complete documentation index at: https://doc.codika.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Codika Agent Plugin

> Install the Codika plugin in Claude Code, Cursor, or any Open-Plugin-compatible agent — deploy, test, and manage use cases directly from your terminal

## Overview

The `codika` plugin gives AI coding agents direct access to the Codika platform. Once installed, your agent can scaffold use cases, validate workflows, deploy to production, trigger executions, debug failures, and autonomously build entire use cases from your business requirements.

It ships as a single [Open Plugin v1](https://github.com/vercel-labs/open-plugin-spec)-conformant repo at [`codika-io/plugin`](https://github.com/codika-io/plugin), so you install it once and the CLI wires it into every compatible host (Claude Code, Cursor, …).

| Component       | What it adds                                                                                                                       |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| **Skills (25)** | `/codika:*` commands that wrap the `codika` CLI — deploy, verify, trigger, fetch, manage integrations, and more                    |
| **Agents (4)**  | Autonomous agents that design, build, modify, and test use cases. Invoked via the Task tool with `subagent_type: "codika:<agent>"` |

## Prerequisites

* A supported agent host (Claude Code, Cursor, …) installed and running
* Node.js 22+
* The `codika` CLI installed (`npm install -g codika`)
* A Codika API key (from the dashboard under **Organization Settings > API Keys**)

If you haven't set up the CLI yet, the agent will guide you through it automatically using the `/codika:setup-codika` skill after installing the plugin.

## Install

<Steps>
  ### Add the plugin

  The simplest path — one command, works everywhere:

  ```bash theme={null}
  npx plugins add codika-io/plugin
  ```

  The `plugins` CLI auto-detects which agent tools are installed on your machine (Claude Code, Cursor, …) and installs into all of them.

  <Tip>
    **Claude Code native alternative.** If you prefer Claude Code's built-in marketplace flow, run:

    ```
    /plugin marketplace add codika-io/plugin
    /plugin install codika@plugin
    ```

    Both paths produce the same `/codika:*` skills and agents.
  </Tip>

  ### Verify the installation

  Ask your agent:

  ```
  Which skills and agents do you have access to?
  ```

  You should see skills prefixed with `codika:` (e.g., `codika:deploy-use-case`, `codika:trigger-workflow`) and the builder agents (`codika:use-case-builder`, `codika:use-case-modifier`, `codika:n8n-workflow-builder`, `codika:use-case-tester`).

  In Claude Code you can reload plugins at any time with:

  ```
  /reload-plugins
  ```
</Steps>

## Authenticate

Before using any platform operations, authenticate the CLI:

```bash theme={null}
codika login
```

Or pass the key directly:

```bash theme={null}
codika login --api-key cko_your_api_key_here
```

Verify with:

```bash theme={null}
codika whoami
```

If you skip this step, the agent will prompt you to authenticate the first time a command fails.

## What you can do

### CLI skills

Ask your agent naturally — it picks the right skill automatically.

| Ask the agent to...              | Skill used                   |
| -------------------------------- | ---------------------------- |
| "Scaffold a new use case"        | `codika:init-use-case`       |
| "Validate my use case"           | `codika:verify-use-case`     |
| "Deploy this use case"           | `codika:deploy-use-case`     |
| "Trigger the main workflow"      | `codika:trigger-workflow`    |
| "Show me the last execution"     | `codika:get-execution`       |
| "List recent executions"         | `codika:list-executions`     |
| "Publish to production"          | `codika:publish-use-case`    |
| "Download the deployed use case" | `codika:fetch-use-case`      |
| "Set up the Slack integration"   | `codika:manage-integrations` |

### Builder agents

For more complex tasks, the agent delegates to specialized sub-agents (invoked via Task tool with `subagent_type: "codika:<name>"`):

| Ask the agent to...                                   | Sub-agent used                |
| ----------------------------------------------------- | ----------------------------- |
| "Build a use case that processes invoices from email" | `codika:use-case-builder`     |
| "Add Slack notifications to this use case"            | `codika:use-case-modifier`    |
| "Build a workflow that calls the Tavily API"          | `codika:n8n-workflow-builder` |
| "Deploy and test this use case, fix any issues"       | `codika:use-case-tester`      |

The builder agents read Codika's platform documentation at runtime (bundled inside the `codika:discover-codika-guides` skill), so they always follow current patterns for triggers, placeholders, credentials, and mandatory nodes.

## Example session

```
You: Build a use case that monitors Gmail for invoices,
     extracts data with Claude, and saves results to Google Sheets

Agent: I'll use the use-case-builder agent to design and create this.
       [reads platform docs via codika:discover-codika-guides]
       [designs architecture]
       [creates config.ts with Gmail trigger, FLEXCRED_ANTHROPIC, USERCRED_GOOGLE]
       [builds 2 workflows: gmail-trigger.json + invoice-parser.json (sub-workflow)]
       [runs codika verify to validate]

       ✓ Use case created at ./invoice-processor/
       Want me to deploy and test it?

You: Yes, deploy and test it

Agent: [deploys via codika:deploy-use-case]
       [triggers via codika:trigger-workflow]
       [inspects execution via codika:get-execution]

       ✓ Deployed and tested successfully
       Version: 1.0.1 | Instance: abc123
```

## Updating

To get the latest skills and agents:

```bash theme={null}
npx plugins add codika-io/plugin
```

Re-running `plugins add` on the same repo pulls the latest version. In Claude Code native:

```
/plugin update codika@plugin
```

## Uninstalling

```
/plugin uninstall codika@plugin
```

To remove the marketplace entry in Claude Code native:

```
/plugin marketplace remove plugin
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="Plugins don't appear after installation">
    In Claude Code, run `/reload-plugins` to force a rediscovery. You should see a count of plugins, skills, and agents in the output. Other hosts usually refresh on the next session restart.
  </Accordion>

  <Accordion title="Authentication errors">
    Run `codika login` followed by `codika whoami` to verify your credentials. If using multiple organizations, make sure the correct profile is active.
  </Accordion>

  <Accordion title="Builder agents can't find documentation">
    The `codika:discover-codika-guides` skill must be available. Verify the `codika` plugin is installed by asking your agent "which skills do you have?". You should see `codika:discover-codika-guides` in the list.
  </Accordion>

  <Accordion title="Deploy or verify commands fail">
    Make sure the `codika` CLI is installed globally (`npm install -g codika`). The skills shell out to the CLI — without it, none of the platform operations work.
  </Accordion>
</AccordionGroup>

## Next steps

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Install the CLI and deploy your first use case.
  </Card>

  <Card title="Builder System" icon="wand-magic-sparkles" href="/builder/overview">
    Deep dive into the autonomous builder agents.
  </Card>

  <Card title="CLI Reference" icon="terminal" href="/operations/overview">
    Complete reference for all codika CLI commands.
  </Card>

  <Card title="Agent Skills" icon="bot" href="/concepts/agent-skills">
    Make your workflows discoverable by AI agents.
  </Card>
</CardGroup>