# Simple Lambda observability, for the AI age

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.

## Get started

Paste this prompt into your coding agent (Claude Code, Cursor, Codex or any agent that can fetch a URL and use a terminal). It signs you up, connects your AWS account and adds tracing; you approve twice in your browser.

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

## Key facts

- Setup takes one prompt to your coding agent, with no code changes.
- No measurable delay on warm invocations; about 20–45 ms on cold starts, because spans are sent after your function has responded.
- Free tier: 100,000 traces a month per workspace. After that, €5 per million traces. One trace is one Lambda invocation.
- Self-hosting is free and MIT licensed: `docker compose up` runs everything.
- Runtime: Node.js on AWS Lambda (with AWS SDK v3, `fetch` and `node:http`). Other runtimes can send OpenTelemetry (OTLP) directly.

## How it works

1. **Paste the prompt.** Your agent reads [llms.txt](https://ivytrace.dev/llms.txt), which tells it how to sign you up and which API calls to make.
2. **Approve in your browser.** You approve the sign-in, then create a CloudFormation stack that gives Ivy a role in your AWS account. No access keys change hands.
3. **See traces.** You pick which functions to trace, by CloudFormation stack, name pattern or tag. New matching functions are traced automatically. The agent invokes one and checks that its trace arrived.

## What you get

- [Lambda tracing](https://ivytrace.dev/features/lambda-tracing): every invocation with its event, response, errors, cold start and logs, and every AWS SDK and HTTP call with payloads.
- [Auto-instrumentation](https://ivytrace.dev/features/auto-instrumentation): one Lambda layer, no code changes, attached by Ivy to the functions you choose.
- [Lambda errors](https://ivytrace.dev/features/lambda-errors): init errors, out-of-memory kills, crashes, timeouts and throttles, grouped by fingerprint.
- [Alerts](https://ivytrace.dev/features/alerts): a Slack message when an error group is first seen, and a weekly email digest.
- [For AI agents](https://ivytrace.dev/features/ai-agents): a remote MCP server across all your workspaces, an HTTP API with OpenAPI, `llms.txt` onboarding and an agent skill.
- [LLM observability](https://ivytrace.dev/features/llm-observability): Vercel AI SDK and OpenTelemetry GenAI spans with prompts, tool calls, tokens and time to first token.
- [OpenTelemetry](https://ivytrace.dev/features/opentelemetry): OTLP ingest, so any OpenTelemetry SDK can send traces.
- [Self-hosting](https://ivytrace.dev/features/self-hosting): the same images as ivytrace.dev, under the MIT license.

## Frequently asked 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](https://ivytrace.dev/features/auto-instrumentation#performance).

### 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](https://ivytrace.dev/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](https://github.com/ivytrace/ivy). The hosted version runs the same code.

---

Source: https://ivytrace.dev/ · Updated 2026-11-14