LiquidMetal AI pricing: how does the $5/month PAYG (with $5 credits) work, and how do I set a max spend limit?

Quick Answer: The $5/month PAYG plan on LiquidMetal AI is a low-friction way to get production-grade Raindrop infrastructure with built‑in cost controls. Your first $5 each month is credited back as usage, and you can hard‑cap spend by setting a max monthly limit in the billing settings so you never exceed your budget.

Most teams want to push agents and RAG workloads into production without waking up to a surprise infra bill. The $5/month PAYG model is designed for that: predictable entry cost, automatic free credits to cover your first usage, and a hard max spend limit you control. You get Raindrop’s SmartMemory, SmartBuckets, SmartSQL, SmartInference, and Actors in a single runtime, but with the same cost predictability you’d expect from a simple SaaS subscription.

Key Benefits:

• Predictable starting cost: Flat $5/month unlocks Raindrop with $5 of included usage, so small projects often “net out” close to zero incremental cost.
• Built‑in cost guardrails: Max monthly spend lets you test agents, RAG, and stateful APIs without worrying about runaway usage.
• Production‑ready from day one: You get versioning, observability, auth, and billing primitives immediately—no extra infra or separate contracts.

Core Concepts & Key Points

Concept	Definition	Why it's important
PAYG base fee	A $5/month platform charge that unlocks Raindrop and its smart primitives.	Gives you predictable access to production infrastructure without long‑term commits.
$5 usage credits	A monthly credit that offsets your first $5 of token + storage usage.	Effectively “rebates” your base fee into real work—many dev/test workloads fit entirely inside this credit.
Max spend limit	A hard cap you set on monthly charges (above the included credits).	Prevents runaway spend from misconfigured agents, loops, or unexpected traffic.

How the $5/month PAYG with $5 credits works (step-by-step)

At a high level: you pay $5/month for access, get $5 in credits automatically, and then only pay beyond that up to whatever limit you set.

1. Activate PAYG and billing

   • Go to the Raindrop dashboard and open Billing.
   • Select the $5/month PAYG plan.
   • Add a payment method (card) and confirm subscription.
   • Once active, your account is billed $5 at the start of the billing period, and $5 in usage credits is applied.

2. Use Raindrop primitives (consume your credits)

   • Every call to:
     • SmartInference (model tokens),
     • SmartBuckets (storage + vector embeddings),
     • SmartMemory (agent state + retrieval),
     • SmartSQL (NL → SQL, PII detection, query execution),
     • Actors / Services (stateful compute), is metered.
   • Usage is tracked in real time and first draws down from your $5 monthly credit.
   • Example pattern:
     • You deploy an agent API with SmartMemory and SmartBuckets.
     • You send ~2M tokens of traffic and store a few GB of data.
     • As long as the metered value stays under $5, you pay nothing beyond the $5 base fee you already paid.

3. Billing beyond the $5 credit (within your max spend limit)

   • When you cross $5 in usage, additional usage is charged pay‑as‑you‑go against your card.
   • Those incremental charges are bounded by the max monthly spend limit you configure.
   • You can:
     • Start with a low cap (e.g., $10/month total usage),
     • Watch how your agents behave under load,
     • Then increase the cap as you move from testing → staging → production.

Because there are no egress fees and pricing is tied to tokens + storage, you can estimate cost per request easily and convert that into a safe cap for your use case.

How to set (and enforce) a max spend limit

You control your own kill switch. The idea is simple: you define the ceiling; the platform enforces it.

Step-by-step:

1. Open Billing in the dashboard

   • Navigate to Settings → Billing.
   • Confirm you’re on the PAYG ($5/month) plan.

2. Set your monthly max spend

   • Look for “Max monthly spend” or “Spend limit”.
   • Enter the total monthly amount you’re comfortable with (including the base fee + overages).
     • Example:
       • You’re okay with up to $25/month total.
       • $5 is the base plan fee; $20 becomes your overage headroom.
   • Save the limit; it takes effect immediately for the current billing cycle.

3. What happens when you hit the limit

   • As your Raindrop usage approaches the limit:
     • You’ll see it in Billing usage charts.
     • You can optionally configure alerts using your observability stack (export logs/metrics).
   • When the limit is reached:
     • Further billable operations are blocked or throttled (depending on your chosen behavior—e.g., hard stop vs. limited fallback).
     • Existing APIs remain defined, but additional costly calls (e.g., large inference runs, heavy ingestion) are prevented to protect your budget.
   • You can raise the limit mid-cycle if you decide to scale up.

4. Adjusting limits as you scale

   • Start with:
     • Dev/POC: $10–$20/month cap.
     • Staging: Cap aligned with expected test load (for example, 10% of projected prod).
     • Production: Cap based on revenue per request or internal budget.
   • Review your observability traces and usage metrics weekly in early rollout.
   • Use these traces to:
     • Tune context lengths,
     • Optimize SmartBuckets usage,
     • Refine agent loops and retries.

Why this pricing model works for agents and RAG, not just simple APIs

Most cloud plans are tuned for stateless functions—“functions that forget everything between requests.” With agents and RAG, cost patterns are different:

• State and memory matter: Agents rely on SmartMemory and Actors to keep context across sessions.
• Storage becomes intelligence: SmartBuckets automatically embed and index your content, so every document you store is immediately searchable.
• Observability is non‑optional: Every AI decision is logged and traceable, which is vital for debugging and cost tuning.

The $5/month PAYG plan maps nicely to these patterns:

• Simple agents, small RAG corpora, and internal tools often live entirely inside the $5 credit.
• As you grow, pay‑as‑you‑go scales linearly with actual work: tokens processed, documents stored, queries run.
• Max spend limit keeps experiments safe—especially when you’re testing:
  • Long‑running agent loops,
  • Multi‑step workflows (e.g., SmartSQL → SmartInference → SmartBuckets),
  • High‑volume chat endpoints.

Common Mistakes to Avoid

• Treating the max spend as a guess, not a guardrail:
  Always size your cap based on a simple back-of-the-envelope model:

  • Estimated requests/day × average tokens/request
  • Plus expected storage growth in SmartBuckets Then add a buffer (e.g., 20–30%) and use that as your cap.

• Ignoring observability when tuning costs:
  Raindrop gives you full traces of SmartInference, SmartMemory, and SmartBuckets operations. Use them:

  • Reduce context length if you see token-heavy prompts.
  • Collapse unnecessary RAG hops.
  • Consolidate Actors if you’re over-sharding per user/session without benefit.

Real-World Example

You’re shipping a customer-support copilot:

• Architecture:

  • SmartBuckets store your docs and tickets; embeddings are automatic.
  • SmartMemory tracks each user’s conversation state across sessions.
  • SmartInference handles responses across 60+ models.
  • Authentication + rate limits are built‑in so you can expose the copilot as a public API.

• Usage pattern (month 1 – internal pilot):

  • ~1.5M tokens across SmartInference.
  • ~5GB of documents in SmartBuckets.
  • Light SmartMemory usage across a few hundred sessions.

This stays within the $5 monthly credit—you pay the $5 base, but effectively “consume” all of it in useful work. You set a $20 max spend as a guardrail. Midway through the month, someone accidentally pushes a version with a verbose, multi-hop agent loop. Because of your cap:

• Usage climbs faster but hard-stops at $20, not $200.
• Traces show the problematic loop.
• You roll back using Raindrop’s complete versioning across code and primitives.
• You fix the agent, redeploy, and selectively raise the cap once you’re confident.

Pro Tip: Treat the spending limit and observability traces as part of your deployment checklist. Each time you roll out a new agent or RAG workflow, temporarily lower the max spend, watch the traces for a day, then raise the cap once you’re sure there are no runaway loops or oversized prompts.

Summary

The $5/month PAYG plan is built for teams who want production-ready AI backends without committing to enterprise-scale spend from day one. You pay a flat $5, get $5 back as usage credits, and then scale pay‑as‑you‑go—protected by a max monthly spend limit you control. With SmartMemory, SmartBuckets, SmartSQL, SmartInference, and Actors all versioned and fully observable, you can move from demo to production while keeping both behavior and cost under tight governance.

Next Step

Get Started