Jungle Grid and Activepieces tutorial showing a real AI job completed in 31 seconds with zero GPU setup.
Activepieces × Jungle Grid Ready Paths

Run a Real AI Job from Activepieces in 31 Seconds

A complete Jungle Grid Ready Paths workflow — from trigger to completed result, with zero manual GPU setup.

Watch the Tutorial
End-to-end workflow runtime

31s

Submit Job response

146ms

Get Job Status response

87ms

Get Job Runtime response

114ms

Final status

Completed

How it works

How Activepieces and Jungle Grid fit together

Activepieces is the automation layer. It starts from a trigger, passes data between steps, calls actions, and decides what happens next after the workload state changes.

Jungle Grid is the execution layer. Ready Paths lets the flow run a defined AI workload without manually provisioning GPU infrastructure, selecting providers, or turning the workflow into a scheduler.

  • Keep triggers, flow branching, data movement, and downstream delivery inside Activepieces.
  • Use Jungle Grid Ready Paths when an automation step needs a real tracked AI workload.
  • Read Jungle Grid status, runtime data, logs, and results back into the Activepieces flow.
Scope

Recorded integration proof: a real Activepieces workflow triggered a Jungle Grid Ready Path and reached a completed job result in 31 seconds.

What Activepieces controls

Activepieces

Low-code automation, event triggers, data movement, and downstream workflow actions.

What Jungle Grid controls

Remote execution

Remote execution layer for Ready Paths, placement, runtime tracking, logs, and results.

Ready Paths fit

Low-code and event-driven workflows that need tracked AI execution without manual GPU setup.

Open Activepieces docs
Quick answer

Activepieces stays in charge of orchestration

Activepieces handles automation flow and downstream actions. Jungle Grid handles remote AI workload execution.

Keep workflow state, app behavior, and orchestration inside the integration tool. Use Jungle Grid when the job itself should run remotely with tracked status, logs, and results.

Architecture flow

Where Jungle Grid fits in the stack

The boundary is intentionally clean: Activepieces owns the workflow, and Jungle Grid owns the AI job lifecycle behind the Ready Path.

Activepieces Trigger
Jungle Grid Ready Path
Job Execution
Status Check
Runtime Result
1

Activepieces trigger

A manual, scheduled, webhook, or app event starts the automation flow.

2

Jungle Grid Ready Path

The flow calls a defined Jungle Grid workload path instead of hand-configuring GPU infrastructure.

3

Job execution

Jungle Grid places and runs the AI workload on matched remote capacity.

4

Status check

Activepieces checks the job state while Jungle Grid remains responsible for runtime tracking.

5

Runtime result

The flow retrieves runtime information and continues once the job reaches its completed result.

Example workflow

Workflow trigger to completed result in 31 seconds

The recorded demo shows a concrete Activepieces flow calling Jungle Grid Ready Paths, checking state, and returning a completed workload without manual GPU setup.

1

An Activepieces workflow starts from a trigger.

2

The flow calls a Jungle Grid Ready Path for the defined AI workload.

3

Jungle Grid submits and executes the job while tracking lifecycle state.

4

Activepieces checks job status and retrieves runtime information from Jungle Grid.

5

The demo displays the final status as completed in 31 seconds.

Code example

Submit a workload and track the job

This example represents the same boundary used by an Activepieces action: call Jungle Grid with workload intent, keep the job ID, then check state and runtime information from the workflow.

The important split is the same on every page: the integration tool decides when work should run, and Jungle Grid executes the workload remotely.

Small code exampleDemo glue code that forwards work to Jungle Grid and then checks the returned job state.
const response = await fetch("/api/junglegrid/jobs", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    workload: "inference",
    model_size: 7,
    image: "your-image:latest",
    command: "python run.py"
  })
});

const job = await response.json();

const statusResponse = await fetch("/api/junglegrid/jobs/" + job.id);
const status = await statusResponse.json();

In this demo, /api/junglegrid/jobs is an app-side route or helper endpoint that forwards work to Jungle Grid. It is shown as integration glue code, not as a claim about a fixed official URL path.

workload

The kind of job Jungle Grid should execute, such as inference, training, fine-tuning, or a batch run.

model_size

A rough sizing hint so Jungle Grid can match the workload to healthy capacity without manual GPU selection.

image

The container image Jungle Grid should launch for the workload.

command

The command executed inside the container when the job starts.

Use cases

Good fits for this pattern

This pattern is strongest when developers want to keep workflow logic inside the integration tool and avoid manually choosing GPUs, providers, or regions for each job.

Use case

Low-code automations that need to trigger real AI execution without asking operators to choose GPUs.

Use case

Event-driven workflows that need status tracking, logs, runtime data, and completed results as workflow state.

Use case

Internal operations flows where Activepieces coordinates systems and Jungle Grid runs the workload.

Copy for LLM

Prompt an LLM with the right layer split

This prompt keeps Activepieces in the orchestration role and Jungle Grid in the execution role so generated demos follow the intended architecture.

Copy for LLM

Prompt template for Activepieces demos

Use this prompt when you want an LLM to scaffold a reference integration without collapsing orchestration into the execution layer.

Build an Activepieces workflow demo that triggers a Jungle Grid Ready Path, stores the returned job ID, checks job status, retrieves runtime information, and shows the workload completed in 31 seconds. Keep Activepieces responsible for workflow automation and Jungle Grid responsible for AI workload execution, placement, logs, and results.

FAQ

Frequently asked

Does Activepieces run the AI workload itself?

No. Activepieces owns the automation flow, triggers, data movement, and downstream actions. Jungle Grid owns the AI workload execution, placement, runtime tracking, logs, and results.

What does Ready Paths add to an Activepieces workflow?

Ready Paths lets the workflow call a defined Jungle Grid workload path without manually provisioning GPU infrastructure or choosing specific providers and GPUs inside the flow.

Did the workload execute in 146ms?

No. The Submit Job action response was 146ms. The full recorded workflow reached a completed job result in 31 seconds.

Next step

Let Activepieces automate and Jungle Grid execute

Use Activepieces for triggers, data movement, and downstream actions while Jungle Grid Ready Paths run the real AI workload with tracked status, runtime data, logs, and results.

Read the docsBrowse integrations
DocsRead Jungle Grid docsSee the workload-first product model, CLI, portal flow, and public docs surface behind these integration patterns.IntegrationsOpen the integrations hubCompare the other workflow, agent, backend, and app-builder patterns that connect to Jungle Grid.Webhook-driven AI workflows that need status tracking and result delivery into other systems.n8n + Jungle GridLet n8n receive events, transform data, and notify downstream systems while Jungle Grid executes the heavy AI job remotely.Visual AI workflows that need tracked remote execution for bigger jobs.Flowise + Jungle GridBuild the workflow visually in Flowise, then send heavy execution to Jungle Grid through an API or custom tool node.