> Full Neon documentation index: https://neon.com/docs/llms.txt

# Claimable Neon, @neon/tools, and more

## Claimable Neon: provisioned by agents, claimed by humans

Claimable Neon is for developers building with agents. When your agent is mid-build, the signup, email verification, or API key it needs to provision a database brings everything to a halt. [Claimable Neon](https://neon.com/claimable-neon) solves this problem. It lets your agent provision a temporary project with scoped credentials, without an account or payment details, and keep building. If you like the result, you can sign in later and claim the project.

```bash
# Agent: provision a claimable project (writes DATABASE_URL to .env)
neon claim create --env-pull

# Human: sign in and take ownership
neon claim accept
```

Today you can provision [Lakebase Postgres](https://neon.com/docs/get-started/why-neon), [the Data API](https://neon.com/docs/data-api/overview), and [Managed Better Auth](https://neon.com/docs/auth/overview) this way, with support for [Object Storage](https://neon.com/docs/storage/overview), [Functions](https://neon.com/docs/compute/functions/overview), and [AI Gateway](https://neon.com/docs/ai-gateway/overview) coming soon.

For how it works, see the [Claimable Neon docs](https://neon.com/docs/reference/claimable-neon) and the [launch blog post](https://neon.com/blog/an-agent-provisions-a-neon-backend-a-human-claims-it-later).

## Give your agent Neon tools with `@neon/tools`

If you're building an AI agent or app that manages Neon itself, such as one that spins up a project or a branch, [`@neon/tools`](https://github.com/neondatabase/neon-pkgs/tree/main/packages/tools) gives it typed, function-calling tools instead of hand-written API wrappers. It turns the [`@neon/sdk`](https://neon.com/docs/reference/typescript-sdk) client into tools you hand to a model. Pick the Neon operations you want to expose, and they stay in sync with Neon's API. It also ships adapters for MCP, Mastra, and Eve.

```ts
import { createNeonTools } from '@neon/tools';

const tools = createNeonTools({
  apiKey: process.env.NEON_API_KEY,
  tools: ['projects.list', 'projects.createAndConnect', 'branches.createAndConnect'],
});

// createAndConnect provisions a project, attaches compute, and returns a connection string
const created = await tools['projects.createAndConnect'].execute({
  name: 'agent-project',
  region_id: 'aws-us-east-1',
});
```

The same `@neon/tools` catalog now powers the hosted [Neon MCP server](https://neon.com/docs/ai/neon-mcp-server) for coding assistants like Cursor and Claude, adding over 70 new tools. Read more in [Give your agent Neon tools](https://neon.com/blog/give-your-agent-neon-tools).

## Faster queries on large computes

Lakebase Postgres now puts much more of a large compute's memory to work as cache. On fixed-size computes of 18 CU and above, shared buffers expand to use up to 75% of available memory, backed by huge pages, so more of your working set stays resident and fewer reads fall through to storage. Cache-heavy workloads can see up to 2x throughput, with no configuration change or restart required.

On an affected compute you can confirm the larger cache with `SHOW shared_buffers` and `SHOW huge_pages`.

For the engineering deep dive, see [Improving Lakebase Postgres compute cache on Neon, Part 1](https://neon.com/blog/improving-lakebase-compute-cache-part-1).

## Fixes & improvements

<details>

<summary>**Scheduled snapshots**</summary>

The most recent scheduled snapshot on a branch is now kept for as long as the branch has an active snapshot schedule, instead of being deleted when it reaches its retention deadline. A branch with a schedule always keeps at least one snapshot to restore from, even before its next scheduled snapshot is created. Older scheduled snapshots and manual snapshots still expire on their normal schedule.

</details>