Integration

Jungle Grid integration

Jungle Grid is a managed GPU execution platform for AI workloads. With this API an agent can estimate a container job's cost and capacity, submit container jobs (inference, training, fine-tuning, batch) or managed text-model inference jobs, follow a job through its status, lifecycle events, logs and runtime details, list and download its output artifacts (a managed inference job's answer comes back inline), cancel it, and upload input files or scripts for a job. Submitting a job starts paid compute that reserves or consumes the account's Jungle Grid credits. The live log stream (server-sent events) and the MCP server routes are not exposed. Authentication is a scoped API key created in the Jungle Grid portal, sent as a Bearer token; its scopes (jobs:estimate, jobs:submit, jobs:read, logs:read) decide which tools work.

Connect Jungle Grid How integrations work

Ask it in chat

Say what should happen.
The workflow builds itself.

When this happens, do that in Jungle Grid.Built from the 14 Jungle Grid tools below, on the connection you add once.

What you can do with Jungle Grid

Each of these is one operation on one endpoint, available both as a workflow step and as a tool an AI agent can call on its own. Nothing bundles several operations into one action, so what a run did stays readable afterwards.

Most endpoints run on the free plan. A few, mainly the ones that publish on your behalf, need a paid plan.

Job, 3 operations

get_jobGet jobGETReturns the current state of a job: status (pending, queued, assigned, running, completed, failed, rejected, cancelled), execution phase, status message, phase timing, delay reason and whether artifacts are ready. Poll it after submit_job.
list_jobsList jobsGETLists the jobs of the API key's workspace, optionally filtered by status, with cursor pagination. Needs the jobs:read scope.
submit_jobSubmit jobPOSTSubmits a container job (image plus command) and returns its job_id at once; the job runs asynchronously on a GPU. Starts paid compute: it reserves or consumes Jungle Grid credits. Needs jobs:submit.

Job input, 2 operations

create_job_inputCreate job inputPOSTCreates an upload slot for a job input or script and returns its input_id, a signed upload_url to PUT the bytes to, and the token that complete_job_input needs once the bytes are uploaded. Needs jobs:submit.
list_job_inputsList job inputsGETLists the files uploaded for jobs (inputs and scripts) with their status, whether they are ready to be referenced by submit_job, and where they mount in the container. Needs jobs:read.

Artifact, 1 operation

list_job_artifactsList job artifactsGETLists the output files of a job (files written under /workspace/artifacts, or result.json for a managed inference job) with their status. Pass an artifact_id to get_artifact_download. Needs jobs:read.

Cancel, 1 operation

cancel_jobCancel jobPOSTCancels a queued or running job: Jungle Grid marks it cancelled, settles its billing and requests teardown. A completed, failed, rejected or already cancelled job answers 409. Needs jobs:submit.

Complete, 1 operation

complete_job_inputComplete job inputPOSTMarks an upload as complete once its bytes were sent to the upload_url from create_job_input, so submit_job can reference its input_id. Needs jobs:submit.

Download, 1 operation

get_artifact_downloadGet artifact downloadPOSTReturns a temporary signed download url for an artifact, with its expiry; for a managed inference result.json it returns the result inline in content. Changes nothing. Needs jobs:read.

Estimate, 1 operation

estimate_jobEstimate jobPOSTEstimates a container job without running it: routed GPU tier and likely GPU type, hourly rate and cost range in USD, queue wait and capacity status, and screening (can_submit). Creates no job and spends nothing. Needs the jobs:estimate scope.

Event, 1 operation

list_job_eventsList job eventsGETReturns the ordered lifecycle events of a job (queued, scheduling, provisioning, startup, retries, failure, cancellation), which exist before any workload log does. No pagination or filters. Needs jobs:read.

Inference job, 1 operation

submit_inference_jobSubmit inference jobPOSTSubmits a managed text-generation job on a Jungle Grid model and returns its job_id at once. Paid: it reserves or consumes credits. When get_job says completed, list_job_artifacts then get_artifact_download return the answer. Needs jobs:submit.

Log, 1 operation

get_job_logsGet job logsGETReturns persisted log entries of a job (stdout and stderr of the workload), paginated with next_cursor. Empty before the process starts; use list_job_events then. Needs logs:read.

Runtime, 1 operation

get_job_runtimeGet job runtimeGETReturns how a job ran: image, command and args, exit code, whether it timed out, start and finish times, the tails of stdout and stderr, and which runtime fields are available. Needs jobs:read.

Use Jungle Grid from Claude Code, Cursor or Codex

Connect Jungle Grid in LiveContext, create an API key in Settings, then add the LiveContext MCP server to your client. Its Jungle Grid operations become tools the client can call, next to every other integration you connected.

Claude Code

claude mcp add --transport http livecontext https://livecontext.ai/mcp --header "X-API-Key: YOUR_API_KEY"

Codex (~/.codex/config.toml)

[mcp_servers.livecontext]
url = "https://livecontext.ai/mcp"

[mcp_servers.livecontext.http_headers]
"X-API-Key" = "YOUR_API_KEY"

Cursor, Claude Desktop and other JSON configs

{
  "mcpServers": {
    "livecontext": {
      "type": "http",
      "url": "https://livecontext.ai/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Set up the MCP server step by step

How to connect Jungle Grid

Create your workspace
Sign up free. Nothing to install.
Connect Jungle Grid once
Add your Jungle Grid connection in Settings. Every tool from this integration reuses it, and secrets are encrypted at rest and visible only to you.
Describe the job in chat
The workflow builds itself in front of you and picks the endpoints it needs. Drag the steps yourself on the canvas whenever you would rather be explicit.