You write the logic. We handle the rest.

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

Trigger pipelines from any scheduler — Vercel cron, GitHub Actions, external webhooks. The platform handles execution, monitoring, and notifications regardless of how the run was triggered.

# Trigger from anywhere
client.trigger_flow_run(flow_id, parameters={
    "source": "s3://bucket/data.csv",
    "batch_size": 100
})
# Platform handles retries, timeouts, alerts

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): ...