A hosted orchestrator. Tasks, workflows, and jobs.

Vercel serverless functions timeout at 10s (Hobby) or 60s (Pro). GraphIngest dispatches tasks to Cloud Run workers asynchronously — your cron route returns instantly while pipelines run for hours in the background.

# Vercel cron triggers the pipeline — returns in <1s
# Pipeline runs for hours on managed infra
@graph(name="nightly-sync", timeout_seconds=7200)
def sync(): ...

deploy()  # cron calls this endpoint

Process 10,000+ documents in parallel with .map(). Each task gets its own timeout, retries, and caching — no cold starts, no connection limits, no 256KB state caps.

@graph(name="batch", timeout_seconds=3600)
def process(doc_ids: list[str]):
    raw = fetch.map(doc_ids)       # 10K parallel
    processed = transform.map(raw) # auto-retry
    return store.map(processed)    # cached

Run multi-agent research pipelines with built-in ReAct loops, tool calling, and LangGraph integration. Fan-out 50 agents in parallel with rate limiting to stay within LLM API budgets.

@agent(name="researcher", tools=[search, scrape],
       model="standard")
def research(query: str) -> str:
    """You are a research assistant."""
    ...

# Fan-out 50 agents in parallel
results = research.map(queries)

When task 49 of 50 fails, restart from task 49 — not from scratch. Completed tasks return cached results instantly. Failed tasks land in a dead letter queue for review.

# Task 49 failed? Resume from exactly there.
client.restart_from_failure(flow_run_id)
# Tasks 1-48: cached results (0ms)
# Task 49: re-executed with retries
# Task 50: runs after 49 succeeds

A small file in your repo asks GraphIngest to start. GitHub’s computer turns off. When the job finishes, the mark on that save turns green or red, and the dashboard shows the run came from GitHub.

uses: graphingest/run@v1
with:
  api-key: ${{ secrets.GRAPHINGEST_API_KEY }}
  flow-id: ${{ secrets.GRAPHINGEST_FLOW_ID }}

Imagine you run an AI writing tool — one enterprise customer kicks off 500 document generations at once, starving every other user. With GraphIngest, per-user concurrency limits cap them at 5 parallel runs, throttling keeps your OpenAI bill under control at 100 calls/min, and priority queuing lets paid users jump the line. One decorator, no custom infrastructure.

@graph(
    name="process-upload",
    concurrency=ConcurrencyPolicy(
        limit=5, key="user_id"
    ),
    throttle=ThrottlePolicy(
        limit=100, period_seconds=60
    ),
    priority=10
)
def process(user_id, file_url): ...

The check step returns yes or no. Yes runs the yes step. No runs the no step. The other step is skipped, and the run page shows that.

yes:
  depends_on: [check]
  when: yes

no:
  depends_on: [check]
  when: no

Cancel a run and it stops. Steps that already finished stay finished. A step that was still going is cancelled. A later call does not continue the job.

PATCH /api/runs/$RUN_ID
Authorization: Bearer $GRAPHINGEST_API_KEY
{ "state": "CANCELLING" }

One step asks, then the job stops. Nothing keeps running. When the answer arrives, the next step starts. If the answer never comes and that step has a time limit, it fails and a restart continues from there.

continue:
  depends_on: [ask]
  wait_for: answer.ready

POST $SIGNAL_URL
{ "event": "answer.ready" }

The job fails at night. In the morning there is a Slack message with the error and a link to that run. You continue from the row that failed. A finished job stays quiet when you choose failures only.

POST /api/settings/notifications
Authorization: Bearer $GRAPHINGEST_API_KEY
{
  "channel_type": "slack",
  "alert_level": "failures_only",
  "config": {
    "webhook_url": "https://hooks.slack.com/services/..."
  }
}

Set a clock on the flow, or type your own cron expression. Every night at 3:00 UTC, the job starts. Nothing stays running between nights.

schedule:
  cron: "0 3 * * *"

A function that fails tries again on its own. If the job still fails, retry it. Functions that already finished stay finished.

@node(max_retries=3)
def transform(data):
    ...