Skip to content
Ivy
Sign in

Simple Lambda observability, for the AI age.

Every invocation, payload and AWS call, for you and your coding agent.

Set up Ivy for my AWS Lambda functions using https://ivytrace.dev/llms.txt

Paste it into your coding agent. It signs you up and adds tracing; you approve twice.

Loading demo…
Interactive copy of the Ivy trace page, with sample data.

The real trace page, with sample data. Click a node in the graph or a row in the timeline.

Setup
One prompt
License
MIT, self-hostable
Free every month
100,000 traces
After that
€5 per million

What is Ivy?

Ivy is open-source (MIT) tracing and error monitoring for AWS Lambda. A Lambda layer records every Node.js invocation with its payloads, AWS SDK and HTTP calls, and the failures that happen outside your handler. You read the traces in the dashboard; your coding agent reads them through an MCP server and an HTTP API. It is free for 100,000 traces a month per workspace, then €5 per million, and free to self-host.

All features Pricing How it compares Docs

How it works

From prompt to first trace in a few minutes

No YAML, no SDK to wire into every handler, no IAM policy to write by hand.

  1. 1

    Paste the prompt

    Your agent reads llms.txt, which tells it how to sign you up and which commands to run. Any agent that can fetch a URL and use a terminal will do.

    ❯ Set up Ivy for my AWS…
    Fetching ivytrace.dev/llms.txt
  2. 2

    Approve in your browser

    The agent opens a sign-in link for you to approve. Then it opens a CloudFormation quick-create link that gives Ivy a role in your AWS account. You review the stack and click Create. No access keys change hands.

    Allow your coding agent to use Ivy? Approve
  3. 3

    See traces

    Pick which functions to trace, by name, stack or tag. New matching functions are traced automatically. The agent invokes one and checks that its trace arrived.

    ✓ Tracing 14 functions matching checkout-*
    ✓ First trace received (3.8 s)

Features

Everything a Lambda trace should show

Built for serverless from the start, so a DynamoDB query looks like a DynamoDB query and not like an anonymous HTTP POST.

Auto-instrumenting layer

Captures each invocation's event, response, errors and cold start, plus every AWS SDK, fetch and http call. No code changes; spans are sent after your response.

Auto-instrumentation

Payloads, safely

Request and response bodies for every call, so you see what was sent, not only that something failed. Size-capped, with keys like authorization and password redacted inside the function.

Lambda tracing

Errors the handler never sees

Init errors, out-of-memory kills, crashes and timeouts, with the last log lines, plus throttles. Errors are grouped, and Slack alerts and a weekly digest tell you about new ones.

Lambda errors

MCP server and HTTP API

Coding agents query traces through a remote MCP server or the HTTP API (with an OpenAPI spec). Traces come back as compact text trees, and as interactive views in hosts that support MCP Apps.

For AI agents

LLM calls

Spans from the Vercel AI SDK and other OpenTelemetry GenAI instrumentations show up with prompts, responses, tool calls, tokens and time to first token. No OpenTelemetry SDK needed.

LLM observability

OpenTelemetry in, open source throughout

Ingest accepts standard OTLP, so the layer is optional. Everything is MIT licensed, and the same images run on ivytrace.dev and on your own servers.

OpenTelemetry

For agents

Let your agent read production

Your agent already has the code. With Ivy it also gets the failing request, the payload that caused it and the stack trace, so it can find the bug and fix it in one session.

  • find_failing_invocations Recent failures for a function, grouped by error
  • get_trace_summary A whole trace as a compact text tree
  • list_error_groups Errors by fingerprint, with counts and first and last seen
  • compare_invocations What differs between a good and a bad run
  • search_invocations By function, status, request ID, path or error message
  • render_waterfall Interactive trace timeline, right in the chat
  • render_graph The trace's service map, right in the chat

MCP server at https://ivytrace.dev/mcp, with OAuth. Or call the HTTP API directly: see the API reference and OpenAPI spec.

Add the Ivy skill to your repo so your agent knows how to debug with Ivy.

Checkout is returning 500s since this morning's deploy. Can you check Ivy?

Ivy· checkout-api-prod-createOrder · 1,383 ms Open in Ivy ↗
  • GetItem checkout-carts
  • POST api.stripe.com
  • generateText gpt-4o-mini
  • SendMessage order-events.fifo
  • ✗ MissingParameter: The request must contain the parameter MessageGroupId.

Publishing to order-events.fifo fails: the FIFO queue needs a MessageGroupId, which this morning's refactor dropped in src/lib/events.ts:42. Payments still go through, so customers get charged without a confirmation.

src/lib/events.ts
  QueueUrl: ORDER_EVENTS_URL,+ MessageGroupId: order.customerId,  MessageBody: JSON.stringify(event),

Fixed it. Want me to find the affected orders?

Hosted or self-hosted

Your traces, on your box if you want

Hosted and self-hosted run the same images. The backend needs no AWS services, only network access to the AWS API to attach the layer.

Self-host with one command

Runs the OpenTelemetry Collector, ClickHouse, the API and the dashboard. Bring any OIDC provider for sign-in. Free and unlimited, under the MIT license. Self-hosting guide 

git clone https://github.com/ivytrace/ivy && cd ivy
docker compose -f deploy/docker-compose.yml up -d --build
✓ Dashboard and API on http://localhost:3000
✓ OTLP/HTTP ingest on http://localhost:4318

Or use ivytrace.dev

Nothing to run or upgrade. Paste the prompt and your agent does the setup.

  • Same dashboard, MCP server and API
  • Connect AWS accounts in the browser
  • Move to self-hosted any time
  • Free for 100,000 traces a month, then €5 per million (pricing)
Get the prompt Sign in

Pricing

Pay per invocation, not per seat

One trace is one Lambda invocation. Every feature is in every plan.

See pricing

Free

€0 per month

100,000 traces a month per workspace, with every feature.

Pay as you go

€5 per million traces

After the free 100,000 each month. Never blocked, billed monthly.

Self-hosted

Free MIT licensed

Unlimited, on your own servers, with docker compose up.

FAQ

Questions

Does Ivy slow my functions down?

No measurable delay on warm invocations, and about 20–45 ms on cold starts, because spans are sent by a small Lambda extension after your function has responded. If Ivy can't be reached, the layer retries briefly, drops the spans and records how many it dropped; it never blocks or crashes your function. See the measurements.

Which runtimes are supported?

Node.js on Lambda (tested on nodejs22.x, nodejs20.x should work), with the AWS SDK v3, fetch and node:http, including bundled code. Other runtimes can already send traces with any OpenTelemetry SDK, since ingest is plain OTLP. A Python layer is next on the roadmap.

What does Ivy get access to in my AWS account?

The CloudFormation stack creates a role that Ivy assumes with an external ID, so it can list your functions and update the layers and environment of the ones you choose to trace. It also adds an EventBridge rule so new functions that match your rules get traced. Nothing is traced until you pick functions. Delete the stack to revoke access.

What about secrets and personal data in payloads?

Payloads are capped in size, and keys that match your redaction list are replaced inside the function, before anything is sent. Keys like authorization, cookie, password and token are redacted by default. If the data must stay in your network, self-host.

How much does it cost?

The hosted version is free for 100,000 traces a month per workspace, then €5 per million traces. One trace is one Lambda invocation. Self-hosting is free. See pricing.

Is it really open source?

Yes, MIT licensed. The layer, the API, the dashboard and the MCP server are all in github.com/ivytrace/ivy. The hosted version runs the same code.

Moving off Lumigo?

Lumigo has announced that its platform shuts down on December 31, 2026. Ivy traces the same Node.js functions with a layer and opt-in auto-trace, and your agent can do the switch for you.

Migration guide Ivy vs Lumigo

Trace your first function today

One prompt. Your agent does the rest.

Set up Ivy for my AWS Lambda functions using https://ivytrace.dev/llms.txt