# How to connect Replicate to Hermes Agent (paste one key, 31 tools)

> Connect Replicate to Hermes with ClawLink: paste your Replicate key once and 31 tools work from chat. No MCP server to run, nothing stored on your machine.

Web version: https://claw-link.dev/hermes/replicate

Most guides for giving Hermes Agent Replicate access start with registering your own OAuth app or pasting API keys into env files, then leave the token refresh and tool wiring to you. ClawLink gives Hermes a more practical Replicate setup: pair once in the browser and your always-on Hermes agent can act on Replicate for you, reading and doing real work on your behalf with no auth, token refresh, or tool wiring to build yourself.

**Start here — paste this into Hermes to set up ClawLink:**

> Set up ClawLink for Hermes and tell me when it's ready.
> 1. Install the plugin: `hermes plugins install ClawLink-HQ/hermes-plugin --enable`
> 2. Start pairing with `hermes clawlink begin`. It prints an approval link, so show me the link and stop, don't wait.
> 3. I'll approve it in my browser, then reply "approved".
> 4. When I say approved, finish setup: `hermes clawlink finish`
> 5. Then run `hermes clawlink test` and tell me whether ClawLink is ready.

## Setup

It takes three steps to connect Hermes to Replicate.

1. **Install ClawLink** — add the plugin to Hermes Agent once.
2. **Connect Replicate** — one-click OAuth in the ClawLink dashboard.
3. **Use it from chat** — ask Hermes Agent in plain English.

**Alternative for any agent (no plugin needed):** if the Hermes Agent plugin route isn't available or doesn't work, any AI agent with shell access can use the ClawLink CLI instead:

```bash
npx -y @useclawlink/cli login          # sign in via browser — no API key to paste
npx -y @useclawlink/cli connect replicate  # connect Replicate (browser OAuth)
npx -y @useclawlink/cli actions replicate  # list available actions
npx -y @useclawlink/cli run replicate <action> --input '<json>'  # execute (add --confirm for writes)
```

### Install by command

The prompt above walks Hermes through this. By hand, it is four commands and a browser approval:

```bash
hermes plugins install ClawLink-HQ/hermes-plugin --enable
hermes clawlink begin    # prints an approval link — open it and approve
hermes clawlink finish   # after approving in the browser
hermes clawlink test
```

Then connect Replicate in the [ClawLink dashboard](https://claw-link.dev/dashboard) — paste your Replicate API key once.

Verify the connection by asking Hermes:

> Call replicate_predictions_create on model \<model name and version> with input \<arguments>, then poll replicate_get_prediction until it finishes and show me the output.

### Using a different agent?

The Hermes plugin is one client of ClawLink's MCP server. Claude Code, Cursor, Codex, or any agent that can run a shell command pairs with the same ClawLink account through the CLI:

```bash
npx -y @useclawlink/cli login
```

`login` opens the same browser approval and stores a credential locally. Once Replicate is connected in the dashboard, that agent calls the same 31 Replicate tools over MCP. Full setup for MCP clients and shell agents: [connect apps to any AI agent](https://claw-link.dev/learn/connect-apps-to-any-ai-agent).

## Replicate MCP for Hermes

Looking for a Replicate MCP server for Hermes Agent? ClawLink connects Replicate to Hermes Agent and exposes 31 Replicate tools your agent can call over [MCP](https://claw-link.dev/learn/what-is-an-mcp-server), with [hosted auth](https://claw-link.dev/learn/oauth-for-ai-agents) and nothing to run or maintain yourself. Using OpenClaw instead? The [OpenClaw Replicate integration](https://claw-link.dev/openclaw/replicate) works the same way.

Every guide for this one starts the same way: edit `~/.hermes/config.yaml`, paste an MCP credentials block, export `REPLICATE_API_TOKEN`, restart Hermes. That is the entire setup this page removes. You paste a Replicate API token once on a hosted setup page, Hermes pairs with `hermes clawlink begin` and `hermes clawlink finish`, and the 31 Replicate tools below are callable from chat. Nothing runs on your machine, no config file is edited, and the token lives server-side. It is the same Replicate account either way, so the same costs apply; what changes is that the machinery between Hermes and Replicate is hosted instead of assembled by hand.

## What the Hermes Agent Replicate integration can do

31 Replicate tools are ready for Hermes Agent once the account is connected. The 29 below are the ones people reach for most; your agent can call all 31.

### 29 of 31 Replicate tools for Hermes

| Tool | What it does |
|---|---|
| **Cancel prediction** `replicate_cancel_prediction` | Cancel a running prediction |
| **Collections list** `replicate_collections_list` | List all collections of models |
| **Create model** `replicate_create_model` | Create a new Replicate model |
| **Create prediction** `replicate_create_prediction` | Create a prediction for a Replicate deployment |
| **Deployments create** `replicate_deployments_create` | Create a new deployment |
| **Files create** `replicate_files_create` | Upload a file to Replicate |
| **Account get** `replicate_account_get` | Get authenticated account information |
| **Collections get** `replicate_collections_get` | Get a specific collection of models by its slug |
| **Deployments get** `replicate_deployments_get` | Get deployment details by owner and name |
| **Deployments list** `replicate_deployments_list` | List all deployments associated with the account |
| **Files get** `replicate_files_get` | Get details of a file by its ID |
| **Files list** `replicate_files_list` | Retrieve a paginated list of uploaded files |
| **Get prediction** `replicate_get_prediction` | Get the status and output of a prediction by its ID |
| **Hardware list** `replicate_hardware_list` | List available hardware SKUs for models and deployments |
| **Models examples list** `replicate_models_examples_list` | List example predictions for a specific model |
| **Models get** `replicate_models_get` | Get details of a specific model by owner and name |
| **Models list** `replicate_models_list` | List public models with pagination and sorting |
| **Models readme get** `replicate_models_readme_get` | Get the README content for a model in Markdown format |
| **Models versions get** `replicate_models_versions_get` | Get a specific version of a model |
| **Models versions list** `replicate_models_versions_list` | List all versions of a specific model |
| **Predictions list** `replicate_predictions_list` | List all predictions for the authenticated user or organization with pagination |
| **Search** `replicate_search` | Search for models, collections, and docs using text queries (beta) |
| **Trainings list** `replicate_trainings_list` | List all training jobs for the authenticated user or organization with pagination |
| **Webhooks secret get** `replicate_webhooks_secret_get` | Get the signing secret for the default webhook |
| **Models predictions create** `replicate_models_predictions_create` | Create a prediction using an official Replicate model |
| **Predictions create** `replicate_predictions_create` | Create a prediction to run a model by version ID |
| **Trainings create** `replicate_trainings_create` | Create a training job for a specific model version |
| **Update models** `replicate_update_models` | Update metadata for a model including description, URLs, and README |
| **Trainings cancel** `replicate_trainings_cancel` | Cancel an ongoing training operation in Replicate |

## Example prompts

**Run a model once**

> Call replicate_predictions_create on model \<model name and version> with input \<arguments>, then poll replicate_get_prediction until it finishes and show me the output.

**Compare models on a task**

> Run the same image prompt through \<model A> and \<model B> with replicate_predictions_create, wait for both, and tell me which output is closer to the brief.

**Audit recent runs**

> Use replicate_predictions_list to show my last 10 predictions, grouped by model, with status and roughly how long each one ran.

**Cancel runaway work**

> Check the predictions I started in the last hour; if any are still running and are not in my list of wanted ones, cancel them with replicate_cancel_prediction and tell me which you stopped.

## How the Replicate tools behave

Details that decide whether a Replicate prompt is a quick run or a paid, rate-limited crawl.

- **Predictions are asynchronous.** `replicate_predictions_create` starts a run and returns a prediction object; the result is not in that response. Follow it with `replicate_get_prediction` until the status settles.
- **Two creation tools exist.** `replicate_predictions_create` and `replicate_create_prediction` both start runs. Use one consistently; the schemas differ in which fields are optional.
- **Every prediction costs per-second GPU time.** Cancelling matters: `replicate_cancel_prediction` stops billing, and it is the tool to reach for when a model runs away.
- **Models have versions, and versions are what you run.** A model name alone is ambiguous; `replicate_models_versions_list` is where runnable version ids come from, and a version string from a blog post can fail like a typo.
- **Hardware is a choice.** `replicate_hardware_list` shows what a given model can run on, and default hardware is not always the cheapest. Asking the agent to check before a long run is a real saving.
- **Training is its own surface.** `replicate_trainings_create`, `replicate_trainings_list`, and `replicate_trainings_cancel` sit apart from predictions, with separate status semantics and the largest bills on the page.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual API key setup plus your own token handling, permission troubleshooting, and tool plumbing for Hermes Agent. That is fine if you want to build and maintain the integration yourself. Most teams just want Replicate working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Credential handling** | Collect, validate, store, and rotate the Replicate API key yourself, then make sure every tool call uses the right account. | Users complete the hosted ClawLink setup once and the connected Replicate account becomes available to the agent without you building credential management. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for Replicate. | ClawLink handles the repetitive integration plumbing so your team can focus on the workflow instead of the infrastructure. |
| **Agent usability** | You still need to expose the right Replicate actions to the runtime in a format your agent can reliably use. | 31 tools for Replicate are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Replicate to AI agents. It is developer infrastructure: Python and TypeScript SDKs, an MCP server, and a catalog past 1,000 apps, aimed at teams shipping agent products. ClawLink is built for Hermes Agent users instead. You install the plugin once, connect Replicate in the browser, and the 31 tools above work from chat. There is no SDK and no config file, and the Replicate key you paste at setup is stored server-side rather than kept in your environment. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### Hermes paired but still can't use Replicate
Pairing is a two-step handshake: run `hermes clawlink begin`, approve the link in your browser, then run `hermes clawlink finish`. If you ran finish before approving, or the approval link expired, run `hermes clawlink begin` again to get a fresh link. Confirm the plugin was installed with `--enable`, then verify with `hermes clawlink test`.

### Connection succeeds but no tools appear
Reconnect Replicate from the dashboard, then start a fresh chat if the runtime still has the old tool catalog loaded.

### "Tool schema not loaded yet" error when calling Replicate tools
Replicate tool schemas load on demand the first time a tool runs and are cached after that, so this error usually clears on its own: wait a few seconds and retry the same request. If every Replicate call keeps failing with it in a fresh chat, reconnect from the dashboard, and contact support if it still persists — that pattern points to a configuration problem on our side, not something you can fix by reconnecting again.

### Replicate returns 403 or "permission denied" on one action while others work
Two usual causes. The connected account may not have access to the specific workspace, inbox, store, or project in the request — check that first. If access looks right, the agent may have sent a placeholder value (like "YOUR_ID" or an example id from documentation) instead of a real one: ask it to run a list or search tool first, then retry the action with a real id from those results. Most failures at this stage are one of these two, not ClawLink bugs.

### Replicate returns "invalid token" although the account shows as connected
This is the query where a competitor page currently gets credit for the answer, so the correct hosted answer matters. The engines' manual-token causes still apply to the value you pasted: Replicate tokens start with `r8_`, so a pasted value with a leading space, a newline from a bad copy, or a different prefix is not the token; and a token that was rotated or revoked in Replicate dies for every consumer at once. In the hosted flow the fix is the same for all of these: generate the current token in Replicate, re-paste it from the ClawLink dashboard, and start a fresh chat so the tool catalog reloads. What does not apply here is the stale-env-var cause, since there is no local environment file for the token to be stale in. If the token is untouched and recent, quote the exact error string before touching the connection, because a 401 on one tool with working others is a permissions question, not a token question.

Ask the agent to diagnose it:

```text
Call replicate_account_get and quote the exact error. Then tell me whether the token this connection uses starts with r8_. Do not retry the failing tool yet.
```

### Replicate returns 403 on one action but works on others
A token that works at all is valid, so a 403 on a single action is about what that action requires, not about the token. The likely causes: the action needs a model or deployment you do not own (running or updating someone else's private model), it is an account-scoped action like webhooks secrets where `replicate_webhooks_secret_get` needs the webhook configured first, or the agent used a placeholder id (a model version string from documentation instead of one from `replicate_models_versions_list`). Have the agent list what it can see and reuse ids from those responses exactly.

Ask the agent to diagnose it:

```text
Tell me which Replicate tool returned 403 and quote the error. Then list the ids that call needed and which earlier call should have produced each one. Do not call Replicate again until I reply.
```

### Replicate starts returning 429 or throttling mid-task
Replicate's documented limits are 600 prediction creations per minute and 3,000 requests per minute on everything else, and it throttles short bursts above them; the response is HTTP 429 with a body that says the rate limit resets in roughly 30 seconds. An agent fanning out many predictions at once is exactly the traffic shape that meets this: each prediction is a separate call, and they all count against the same allowance. The response is not to retry in a tight loop, which keeps resetting the window, but to spread the work: run predictions sequentially, check `replicate_get_prediction` between starts, and let the agent report the throttle message instead of guessing. If you genuinely need more than 600 prediction starts per minute, that is a support request to Replicate, not something a reconnect fixes.

Ask the agent to diagnose it:

```text
Tell me how many Replicate calls you made in the last minute and what you were running. Quote the exact 429 body. Do not call Replicate again until I reply.
```

### Replicate tools are missing, or one tool name is not found
Two different failures. If Hermes shows no Replicate tools at all, the connection or the pairing is incomplete: confirm the plugin was installed with `--enable`, that both `hermes clawlink begin` and `hermes clawlink finish` ran, and that Replicate shows as connected in the dashboard. If most tools work and a single name fails, that name is wrong rather than missing, and the error lists the closest real ones. There is also a first-call timing case unique to this setup: schemas load on demand, so the opening Replicate call in a fresh session can arrive before the catalog and needs one retry. What does not apply is the usual advice for this symptom, which assumes a local MCP server declared in a client config file.

Ask the agent to diagnose it:

```text
List the Replicate tools you actually have access to. If there are none, say so plainly. If there are, tell me which one starts a prediction and use that exact name.
```

### API key setup works but results look incomplete
Double-check that the API key for Replicate has the right scopes or account access. A valid key can still be too limited for some reads or writes.

### Is there a Hermes Agent Replicate integration?
Yes. ClawLink is the fastest way to connect Hermes to Replicate: link your Replicate account once in the browser and Hermes Agent can call the Replicate API through 31 ready-made tools — no custom code or token handling.

### How do I connect Replicate to Hermes with ClawLink?
Install the plugin with `hermes plugins install ClawLink-HQ/hermes-plugin --enable`, then pair once: run `hermes clawlink begin`, approve the link in your browser, and run `hermes clawlink finish`. Connect Replicate in the dashboard and Hermes can use it from the next message — no config files, and the Replicate key you paste is stored server-side instead of in your environment.

### How long does it take to connect Replicate to Hermes Agent?
About two minutes. Sign in, click Connect next to Replicate in the dashboard, authenticate, and Hermes Agent can use it from the next chat message.

### Why use ClawLink instead of wiring Replicate up myself?
The alternative to ClawLink is usually manual API key setup plus your own token handling, permission troubleshooting, and tool plumbing for Hermes Agent. That is fine if you want to build and maintain the integration yourself. Most teams just want Replicate working from chat.

### Which token does this need, and where does it end up?
A Replicate API token, generated in your Replicate account settings, pasted once on the hosted setup page. Replicate tokens start with `r8_`, which makes a pasted token easy to sanity-check: a value that does not start with `r8_` is not a Replicate token at all. The token is stored server-side rather than in a `.env` or a CLI config, so it is not sitting on any machine you have used, rotating it in Replicate means updating one place, and disconnecting from the ClawLink dashboard revokes the agent's use of it immediately.

### What can the agent do with the Replicate tools?
Run and manage predictions, the core Replicate action: `replicate_predictions_create` and `replicate_create_prediction` start model runs, `replicate_get_prediction` follows them, `replicate_cancel_prediction` stops them, and `replicate_predictions_list` reviews history. Around that sit the model surface (browsing and getting models, versions, and readmes), training runs, deployments, and account and hardware lookups. The writes to be deliberate about are prediction and training runs, because they are paid per-second GPU time on your account.

### How expensive can an agent get?
Replicate bills per second of GPU time, so cost scales with what the agent runs and for how long. A small classification model is a few seconds; a large image or video model can run for minutes, and training runs are the expensive end. The practical guardrails are to have the agent state which model it intends to run and why before running it, to cancel long predictions that no longer matter (`replicate_cancel_prediction`), and to check `replicate_hardware_list` before assuming a model's default hardware is the cheap option. The models an agent chooses matter more than anything in the dashboard.

### Is it safe to connect Replicate to an agent through ClawLink?
The AI Overviews' own answer is that it is generally safe with least-privilege keys, and the risk list it gives is worth taking literally: credential exposure, prompt injection, and cost runaway. Here the credential exposure surface is small, because the token is held server-side and never written to a local config file, but the other two are unchanged. A prompt-injection vector is an agent being told by untrusted content to "run this model now", and cost runaway is an agent retrying a failed model in a loop, each retry paid per second. A token with a spending limit, and a prompt that makes the agent explain before running, covers most of what actually goes wrong.

### How is this different from connecting Replicate through Composio?
The Replicate API underneath is the same, so the capability difference is small; the setup difference is not. The Composio route that search results teach involves their Connect MCP URL and a consumer API key pasted into `~/.hermes/config.yaml`, then a restart, infrastructure you then own. Here the plugin install and one pairing handshake are the entire client-side story, and Replicate sits alongside your other connected accounts with one place to revoke. Choose on how much you want to run, not on features.

### Hermes paired but still can't use Replicate
Pairing is a two-step handshake: run `hermes clawlink begin`, approve the link in your browser, then run `hermes clawlink finish`. If you ran finish before approving, or the approval link expired, run `hermes clawlink begin` again to get a fresh link. Confirm the plugin was installed with `--enable`, then verify with `hermes clawlink test`.

## Related

- [Hermes DataRobot integration](https://claw-link.dev/hermes/datarobot) — DataRobot is a machine learning platform that automates model building, deployment, and monitoring, enabling organizations to derive predictive insights from large datasets.
- [Hermes Chatbotkit integration](https://claw-link.dev/hermes/chatbotkit) — ChatBotKit is a platform that enables developers to build and manage AI-powered chatbots, offering comprehensive APIs and SDKs for seamless integration into applications.
- [Griptape tools](https://claw-link.dev/hermes/griptape) — Griptape is a comprehensive platform offering tools and frameworks for building, deploying, and scaling generative AI applications.