pumaDB
Shared memory API for AI agents — no database setup.
pumaDB is a pragmatic choice for agent memory if you value instant setup over scale. The free tier is generous enough for personal use, but the 25 MB cap and row limits will feel tight for anything beyond light experimentation. Worth trying for its simplicity — just don't expect it to replace a database for serious production loads. If you need relational queries or high throughput, consider Supabase or a managed Postgres.
Verified 7d ago · liveness 71/100 · cite: rightaichoice.com/tools/pumadb
- Developers building AI agent workflows needing persistent memory
- Teams using LLM-based agents (ChatGPT, Claude) for task automation
- System integrators creating agent handoff contexts
- Developers needing lightweight, schema-less JSON storage for agents
- Applications requiring relational database features (joins, foreign keys)
- High-throughput production systems with thousands of concurrent users
- Use cases needing large blob storage (video, images) or exceeding 25 MB
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip pumaDB if you need relational queries (joins, foreign keys), high throughput, large file storage, or client-side browser access, because it's designed for lightweight JSON agent memory.
Exceeding 25 MB free storage or 1,000 rows per table requires upgrading to Organization Pro at $99/month for 250 MB and 2,500 rows per table.
pumaDB's free Personal tier gives you 20 tables and 25 MB storage—plenty for solo agent experiments. At $99/month, Organization Pro fits small teams needing shared memory. Compared to Supabase's free tier (500 MB database) and paid plans, pumaDB is pricier per GB but simpler; for heavy relational workloads, Supabase offers better value.
In short
pumaDB — Shared memory API for AI agents — no database setup. Best for Developers building AI agent workflows needing persistent memory, Teams using LLM-based agents (ChatGPT, Claude) for task automation, System integrators creating agent handoff contexts. Free to start; paid plans from $99/mo.
What people actually say about pumaDB — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
7 mentions across 1 source (Product Hunt) · researched Jul 2, 2026.
- +Dead simple setup: no database project or schema design needed.
- +MCP and REST APIs make integration with ChatGPT and Claude trivial.
- +Automatic version history for all updates and deletes.
- +Consolidated 'remember' MCP tool with safety metadata.
- +Per-key rate limits prevent runaway agent writes.
- −No automatic memory capture—agents must explicitly save state.
- −Memory inspection and correction tools are unaddressed by builder.
- −Limited community presence outside Product Hunt launch thread.
- −Free tier table/row limits may not suit serious production workloads.
- −No public uptime or reliability guarantees available.
- • No pricing page found; future paid tiers unknown, may remove free features at any time.
Viability Score
How well maintained and how widely used is pumaDB? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: August 2026
How we score →Key Features
- MCP (Model Context Protocol) support for agent clients
- REST API for server-side applications with bearer tokens
- Email OAuth authentication for MCP clients
- Automatic version history (last 10 versions, retained 30 days)
- Consolidated remember MCP tool with safety metadata
- Batch operations and upsert endpoints
- Row-level restore from archived versions
- Short-lived shareable links for rows, queries, and large text
- API key management for multiple environments
- Natural edit with filtered updates via plain language
- Scoped table limits (20 tables, 1,000 rows per table on free tier)
- Per-key rate limits (30 writes, 60 reads per minute)
- Viewer links for large text and result sets
- Supports Streamable HTTP MCP clients (Codex, ChatGPT, Claude, OpenClaw)
- Shared org tables for team collaboration (Pro plan)
About pumaDB
pumaDB is a lightweight, hosted JSON database built specifically for AI agent memory. It eliminates the need to manage a traditional database, letting developers using tools like ChatGPT, Claude, Codex, and OpenClaw store persistent facts, state, notes, and handoff context across sessions. With two access methods — MCP (Model Context Protocol) for agent clients with email OAuth, and a REST API for server-side apps with bearer token authentication — pumaDB keeps the same memory surface accessible from both agents and backend code. Key features include automatic version history (last 10 versions per row, retained 30 days), scoped table limits (20 tables at 1,000 rows each on the free tier), per-key rate limits (30 writes, 60 reads per minute), a consolidated "remember" MCP tool with safety metadata, viewer links for sharing large text and results, and batch operations with upsert endpoints. Total storage is capped at 25 MB on the free plan. Compared to full relational databases like Supabase or Firebase, pumaDB deliberately trades relational features and scale for zero-configuration agent memory, making it ideal for prototyping and small-scale agent workflows where setup friction matters more than throughput.
Behind the Verdict
pumaDB shines as a backend memory layer for AI agents. Its core value is simplicity: you point Codex, ChatGPT, Claude, or OpenClaw at a hosted MCP endpoint, sign in with email, and start persisting and retrieving facts across sessions without any database schema or infrastructure. That's a huge win for developers prototyping agent workflows. On the other hand, it's deliberately minimal. You get JSON rows in tables, equality filters, and version history — but no joins, no foreign keys, no aggregation. If your agent needs complex relational queries or very large datasets, pumaDB isn't the right tool. Storage caps (25 MB free, 250 MB Pro) and rate limits (30 writes/60 reads per minute per key) also mean it's not built for high-throughput production loads. Where pumaDB really fits is exactly what it markets: a shared memory that follows your work. The consolidated `remember` MCP tool with safety metadata and batch upserts makes it easy to log transactions, decisions, and handoff notes with minimal code. The REST API mirrors the same tables, so you can have both agent-written and server-written data in one place. Its weaknesses: no on-prem deployment, no client-side usage, and the free tier's 25 MB cap fills up fast if you store verbose content. Teams needing SSO, audit logs, or custom limits will need Enterprise (annual contract). But for individual developers and small teams already invested in OpenAI/Anthropic agents, pumaDB cuts setup time to minutes, and that's valuable.
Researching pumaDB? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas pumaDB actually fits — and what changes day-one when you adopt it.
You're building a coding agent that tracks bugs and decisions across sessions. You connect pumaDB via MCP with email OAuth, create a 'bugs' table, and use the 'remember' tool to log each bug with id and cause. Later, you open a fresh Claude chat and ask it to pick up the bug; it queries the table and returns the cause instantly.
Outcome: Zero configuration, durable memory across different AI tools, and no database project to manage.
Your team shares a pumaDB Organization Pro plan. One member logs preferences and project conventions, another uses the REST API to write task states from a backend cron, and a third queries via MCP to generate handoff notes. All data lives in shared org tables visible to the whole team.
Outcome: Consistent context across team members and AI tools, reducing repetitive explanations and improving continuity.
You build a serverless function that calls the REST API to store research clippings (source, summary, link) into a 'clippings' table. Meanwhile, an agent uses MCP to query and summarize those clippings for a weekly report. You also set up API keys for prod and dev environments.
Outcome: A single memory surface serves both backend code and AI agents, with secure bearer auth and separate keys per environment.
Use Cases
- Log agent reasoning steps and intermediate state into durable tables for debugging.
- Store cross-session user preferences (e.g., communication style, formatting defaults).
- Persist project conventions and architecture notes so agents don't rediscover them.
- Record research clippings with summaries and links for long-running investigations.
- Maintain open task status, blockers, and handoff notes across agent sessions.
- Save reusable markdown skills that agents can load on startup.
Models Under the Hood
as of 2026-08-21
Limitations
- pumaDB is a shared memory layer for AI agents, not a general-purpose database.
- It is optimized for small structured records (projects, facts, decisions) rather than large-scale datasets.
- API keys are bearer secrets that must be kept server-side.
- Version history retains 10 versions per row for 30 days.
as of 2026-08-11
Verification history
We have re-verified pumaDB 6 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published pumaDB tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Personal
$0/mo
Ideal for
Solo developers and hobbyists who want zero-cost persistent memory for personal agent experiments, with 20 tables and 25 MB storage enough for light use.
What this tier adds
Free entry point with 20 tables, 1,000 rows per table, 25 MB storage, hosted MCP + REST, and version history.
Organization Pro
$99/month
Ideal for
Small teams needing shared memory across multiple members and agents, with up to 100 team members and 250 MB storage.
What this tier adds
Adds shared org tables, admin/member roles, 50 tables (2,500 rows each), 250 MB storage, and up to 100 team members.
Enterprise
Custom
Ideal for
Larger organizations requiring custom limits, security, procurement support, and annual scoped contracts.
What this tier adds
Provides custom team member and storage limits, plus security, procurement, and rollout support, with annual contract.
Where the pricing makes sense
The company stage and team size where pumaDB's pricing actually pencils out — and where peers do it cheaper.
pumaDB's free Personal tier gives you 20 tables and 25 MB storage—plenty for solo agent experiments. At $99/month, Organization Pro fits small teams needing shared memory. Compared to Supabase's free tier (500 MB database) and paid plans, pumaDB is pricier per GB but simpler; for heavy relational workloads, Supabase offers better value.
Setup time & first value
How long it actually takes to get something useful out of pumaDB — broken out by persona, not the marketing-page minute.
Solo developer: create account and connect MCP in ~5 minutes; first write/read via REST in ~10 minutes using quickstarts. Team: Organization Pro setup takes ~15 minutes to invite members and configure shared tables; Enterprise setup requires sales discussions and may take days.
Switching to or from pumaDB
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From a local JSON file or script: manually POST rows to pumaDB via REST API, then update your code to use the API.
- →From a spreadsheet: export to JSON and bulk-upload using the batch/upsert endpoints.
- ↗To Supabase or a relational DB: export your JSON rows and map them to SQL tables; note the loss of version history.
- ↗To a local SQLite: dump pumaDB rows to JSON and import into SQLite using a script.
Integrations
Resources & Guides
Tutorials & Learning
Official links
Tools that pair well with pumaDB
Common stack mates teams adopt alongside pumaDB, with the specific reason each pairing earns its keep.
Featured Head-to-Head Comparisons
Pumadb vs Spider Cloud
Choose Spider Cloud if your AI agent needs fresh, structured web data at scale with low cost and rich integrations. Choose pumaDB if your priority is simple, schema-less persistent memory for agent state, handoffs, and notes without database overhead. They solve different problems: one feeds data in, the other stores it.
Pumadb vs Voyage Ai
Voyage AI and pumaDB solve entirely different problems – Voyage is for retrieval accuracy in complex enterprise RAG, while pumaDB is a simple memory layer for AI agents. If your need is semantic search over legal or financial docs with long contexts, Voyage is the specialist. If you're building agentic workflows (ChatGPT, Claude, Codex) that need persistent state without a database, pumaDB's MCP-native approach is a natural fit. They are complementary, not competitive.
Pumadb vs Temporal Ai
Choose Temporal AI if you need rock-solid orchestration for complex AI agents or microservices—it automatically handles retries, state, and recovery at scale. Pick pumaDB if your primary need is a lightweight, schema-less memory store for simple agent interactions (like ChatGPT or Claude) with minimal setup. For production-grade workflows with human-in-the-loop, Temporal wins; for quick prototyping of agent memory, pumaDB is simpler.
Alternatives to pumaDB
View allFrequently Asked Questions
Used pumaDB? Help shape our editorial sentiment research.