Replicate connector for AI agents

Tools your ML ops agent reaches for on Replicate, scoped per user.

CALL ANY TOOL

33 tools for model hosting on Replicate: search models and collections, run and cancel predictions, start trainings, create and update deployments, read model versions and READMEs, and manage models and files.

replicate_cancel_prediction

Cancel prediction

Cancel a prediction that is still starting or processing. Returns the prediction object with its updated status. Use it to stop a run you no longer need. It has no effect on a prediction that already finished. Prerequisite: the prediction ID from a create-prediction tool or replicate_list_predictions.

Parameters

Name

Type

Required

Description

prediction_id

string

Required

ID of the prediction to cancel.

replicate_cancel_training

Cancel training

replicate_create_deployment

Create deployment

replicate_create_deployment_prediction

Create deployment prediction

replicate_create_model

Create model

replicate_create_model_prediction

Create model prediction

replicate_create_prediction

Create prediction

replicate_delete_deployment

Delete deployment

replicate_delete_file

Delete file

replicate_delete_model

Delete model

replicate_delete_model_version

Delete model version

replicate_get_account

Get account

replicate_get_collection

Get collection

replicate_get_deployment

Get deployment

replicate_get_file

Get file

replicate_get_model

Get model

replicate_get_model_readme

Get model readme

replicate_get_model_version

Get model version

replicate_get_prediction

Get prediction

replicate_list_collections

List collections

replicate_list_deployments

List deployments

replicate_list_files

List files

replicate_list_hardware

List hardware

replicate_list_model_examples

List model examples

replicate_list_model_versions

List model versions

replicate_list_models

List models

replicate_list_predictions

List predictions

replicate_search

replicate_update_deployment

Update deployment

replicate_update_model

Update model

For more tools, view docs.

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Replicate tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["replicate"], toolNames: [
    "replicate_search",
    "replicate_create_model_prediction",
    "replicate_get_prediction"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Find an image upscaling model and run it on this photo" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["replicate"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Find an image upscaling model and run it on this photo" }],
  tools,
});

// Execute the tool call with the user's vaulted Replicate access token
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["replicate"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Find an image upscaling model and run it on this photo" }],
  tools,
});

// Tool call runs with the user's vaulted Replicate access token
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["replicate"] }, pageSize: 100,
});

const agent = new Agent({
  name: "ml_ops_agent",
  model: "gemini-2.5-pro",
  instruction: "Replicate tools scoped to this user",
  tools,
});

await agent.run("Find an image upscaling model and run it on this photo");

Try these prompts

Copy any prompt into your agent. Each maps directly to a Replicate tool. Click to copy, paste into your agent, done.

Models

Copy the prompt

Copied

Search Replicate for image upscaling models.

Copy the prompt

Copied

Show the input schema for the latest version of this model.

Copy the prompt

Copied

List the models in the text-to-image collection.

Predictions

Copy the prompt

Copied

Run an official text-to-image model on a fox in the snow.

Copy the prompt

Copied

Check the status of my last prediction.

Copy the prompt

Copied

Cancel the prediction that is still processing.

Deployments and trainings

Copy the prompt

Copied

Create a deployment of our model on GPU hardware with 2 max instances.

Copy the prompt

Copied

Start a training that fine-tunes this model on our dataset.

Copy the prompt

Copied

List our deployments and their hardware.

SEE HOW AUTH WORKS

Each user connects their own Replicate access token once, and Scalekit sends it with every call. Access tokens stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

Replicate

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

Replicate

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

Replicate

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

Replicate

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other AI connectors.

Engineering Teams

DevOps assistant agent

Polls GitHub for failing checks and stale PRs, opens Linear issues for the ones that need work, and posts a daily digest to Slack. It acts as the engineer, not a shared service account.

GTM and RevOps Teams

Competitive intelligence briefing agent

Scans Gong calls for competitor mentions, matches each one to its Notion battlecard, and DMs every affected rep a single Slack digest per cycle. Every call runs as the PMM who owns the briefing, never a shared bot.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared Replicate access token looks fine in a demo. In production every prediction and deployment looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared key
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Replicate today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Replicate as the user or through a shared access token?

As the user. Each user connects their own Replicate access token once, and Scalekit sends it with every call. Audit logs attribute every prediction and deployment change to that user, not a shared service account.

Where is the Replicate access token stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. To rotate it, the user reconnects with a new access token. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in Replicate?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example model search and predictions without replicate_delete_model or replicate_delete_model_version, which deletes a version with all its predictions and output files. Scalekit also enforces scope checks before every API call.

What happens when a user revokes Replicate access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Which Replicate account does the agent act in?

The user or organization that owns the connected access token. replicate_get_account returns that account's type and username, and the prediction and training lists show only runs created by that account.