LiquidMetal AI vs HazelJS: differences in persistent agent state, retrieval/storage primitives, and production readiness

Most teams building agentic backends run into the same wall: getting from a working demo to a production system with persistent state, reliable retrieval, and observability that doesn’t collapse into glue code. Comparing LiquidMetal AI’s Raindrop with HazelJS through that lens comes down to three things: how they handle persistent agent state, what retrieval/storage primitives they provide out of the box, and how production-ready they are on day one.

Quick Answer: LiquidMetal AI’s Raindrop treats intelligence, memory, and storage as first-class primitives—SmartMemory, SmartBuckets, SmartSQL, SmartInference, and Actors—so state, retrieval, auth, billing, and observability are built in, not bolted on. HazelJS is a flexible agent framework, but you’re responsible for wiring your own databases, retrieval stack, auth, and production hardening. If you want an agent-native runtime with persistent memory and AI-ready storage from day one, Raindrop is the more production-ready choice.

Why This Matters

The biggest failure mode in agentic projects isn’t “can the model reason?”—it’s “can we run this in production without a bespoke RAG stack, ad-hoc state management, and a tangle of services nobody wants to maintain?”

Choosing the right runtime affects:

• How you model and persist agent state across sessions and workflows
• Whether retrieval and storage are AI-ready by default or stitched together later
• How fast you can ship a monetized, observable, rollback-safe API instead of a fragile prototype

For teams focused on generative experiences and GEO-aware APIs, this is the difference between shipping in days or bleeding weeks into infrastructure.

Key Benefits:

• Reduced glue work: Raindrop removes the need to stitch together vector DBs, RAG pipelines, and separate memory stores just to keep agents coherent.
• Production from day one: Built-in auth, billing, versioning, and observability let you ship a sellable API, not just a demo.
• Agent-native architecture: Persistent state, event-driven observers, and smart primitives are designed specifically for autonomous and semi-autonomous agents.

Core Concepts & Key Points

Concept	Definition	Why it's important
Persistent Agent State	How an agent maintains memory, context, and identity across requests, sessions, and long-running workflows.	Determines whether your agent can act coherently over time without fragile external state glue.
Retrieval/Storage Primitives	Built-in ways to store, index, and query data (documents, blobs, tables) that are directly usable by AI.	Reduces the need for custom RAG stacks and ensures consistent, observable retrieval behavior.
Production Readiness	The set of features (auth, billing, versioning, observability, scaling) that turn an agent from a demo into a reliable product.	Impacts time-to-market, operational risk, and ability to safely iterate and roll back changes.

How It Works (Step-by-Step)

Below is how the two platforms differ across the core lifecycle: define an agent, give it memory, attach retrieval, and ship it as an API.

1. Persistent Agent State

Raindrop (LiquidMetal AI)

Raindrop is built around the idea that “functions that forget everything between requests” are a poor foundation for agents. It offers:

• Actors → Stateful compute units

  • Each Actor has a persistent identity and persistent data.
  • Requests are routed to the right Actor instance, so per-user or per-session state is natural.
  • Built-in scheduling/alarms enable recurring tasks, retries, and long-running workflows without extra infra.
  • Isolation by design: one actor’s state can’t bleed into another user’s data.

• SmartMemory → Structured agent memory

  • Supports working vs. episodic and semantic vs. procedural memory patterns.
  • Handles session rehydration, so agents can pick up where they left off without manually orchestrating context.
  • Integrated with the rest of the runtime: you don’t bolt on a separate memory store.

• Observers → Event-driven evolution

  • Observers react to events and traces, letting agents update their own memory or trigger workflows.
  • This enables continuous learning loops while preserving versioned, auditable behavior.

State is native to the compute model, automatically versioned with code and data. You don’t have to wire your own state layer just to get agents that remember.

HazelJS

HazelJS is fundamentally a library/framework for building agents:

• Agent “state” is typically:
  • In-memory while the process runs, and
  • Persisted via external systems (e.g., Postgres, Redis, vector DBs) that you choose and integrate.
• No built-in actor-like abstraction for identity-routed, persistent compute.
• Long-running or recurring workflows require:
  • An external scheduler/queue (e.g., cron, queues + workers)
  • Custom logic to load/save state between invocations.

You can absolutely build persistent agents with HazelJS, but state is your responsibility—modeling, persistence, consistency, and isolation are not part of the runtime itself.

2. Retrieval & Storage Primitives

Raindrop: AI-Ready Storage Built In

Raindrop treats storage as an AI primitive, not just a blob bucket.

• SmartBuckets

  • S3-compatible object storage.
  • Automatic vector embeddings on ingest → instant semantic search.
  • Keyword and semantic search out of the box.
  • Graph-based search to model relationships between entities and documents.
  • No separate vector DB or embedding pipeline required.

• SmartSQL

  • Natural language to SQL with schema-aware reasoning.
  • Automatic PII detection and schema intelligence.
  • Example caliber: “Query 203,466 real Chicago crime records in plain English.”
  • Great for analytics agents and internal tools where governance of data access matters.

• SmartInference

  • Unified interface to 60+ models with automatic scaling.
  • Centralizes LLM access so you’re not scattering model calls across services.

The net result: no stitching together vector databases, RAG pipelines, and separate memory stores. Your retrieval becomes:

• SmartBuckets for documents and blobs
• SmartSQL for structured data
• SmartMemory for agent-specific context
• All of it versioned, observable, and governed within the same runtime.

HazelJS: BYO RAG Stack

HazelJS offers:

• Integration points where you can call:
  • Vector databases (Pinecone, Chroma, pgvector, etc.)
  • Object stores (S3, GCS, etc.)
  • Your own relational DB
• Some helper utilities and patterns for:
  • Tools
  • Web search or RAG calls
  • Multi-step agent flows

But it doesn’t ship SmartBuckets-like storage or SmartSQL-like schema intelligence. You’re responsible for:

• Picking and provisioning a vector DB.
• Wiring an embedding pipeline.
• Designing your own chunking/indexing strategy.
• Implementing access controls and PII handling at the application layer.
• Tracing retrieval behavior across multiple systems.

In short: HazelJS is agent logic; retrieval/storage is external and custom.

3. Production Readiness

Raindrop: Production-Ready From Day One

Raindrop is a runtime for production APIs, not just agent experiments. Out of the box you get:

• Authentication

  • JWT and OAuth support.
  • RBAC (role-based access control).
  • API keys for programmatic access.
  • All integrated declaratively with your API manifests.

• Monetization

  • Tiered plans and usage tracking.
  • Rate limiting and quota enforcement.
  • Payments handled, so you can sell the API, not just expose it.

• Complete Versioning

  • GitHub-style branching for code, data, and smart primitives.
  • Instant rollback/rollforward:
    • Experiment with a new agent memory policy.
    • Roll back if behavior regresses.
  • “Know exactly what changed and why” across your stack.

• Full Observability

  • Every AI decision logged and traceable.
  • Smart primitive operations (SmartMemory, SmartBuckets, SmartSQL, SmartInference) are visible for debugging and audits.
  • Observer events and Actor behavior are part of a coherent trace.

• Automatic Scaling

  • Global scaling without configuration.
  • Built for agent workloads rather than one-off request handlers.

This is where Raindrop’s “Intelligence as a primitive” stance shows: auth, billing, observability, and scaling are native concerns, not afterthoughts.

HazelJS: Framework-First, Ops Later

With HazelJS, production readiness is mostly a DIY exercise:

• Auth & Billing

  • Implemented via whichever API gateway or backend you pair it with.
  • No built-in JWT/OAuth/RBAC stack for you; you bring your own.
  • Monetization (plans, quotas, billing) handled by your surrounding infrastructure.

• Versioning & Rollback

  • Standard app-level approaches:
    • Git for code.
    • DB migrations or feature flags for behavior.
  • No unified “code + data + primitive configuration” versioning model.

• Observability

  • Logging/tracing through your chosen stack (OpenTelemetry, vendor APM, etc.).
  • No built-in, agent-native traceability across memories, tools, and retrieval unless you implement it.

HazelJS lets you target whichever environment you prefer (Node, serverless, containers), but the hosting environment defines your ops story, not HazelJS itself. Raindrop, by contrast, is hosting + primitives + governance in one system.

How It Works (Step-by-Step)

From the perspective of a team shipping an agentic API, here’s how the build path diverges.

1. Define Your Agent & API

   • Raindrop:

     • Write a simple manifest in Developer Mode, or
     • Use AI Mode: describe the API you need and Raindrop builds, tests, and deploys a complete API.
     • You define endpoints, Actors, and observers declaratively.

   • HazelJS:

     • Install the library, define your agents in TypeScript/JavaScript.
     • Build your own API layer around them (framework of choice, routing, etc.).

2. Wire Memory and Retrieval

   • Raindrop:

     • Attach SmartMemory to your agents for persistent state.
     • Use SmartBuckets for documents and SmartSQL for analytics/structured data.
     • No extra embedding services or vector DB required.

   • HazelJS:

     • Choose and integrate:
       • Vector DB,
       • Object storage,
       • Relational DB.
     • Implement embedding, chunking, and retrieval logic yourself.

3. Ship to Production

   • Raindrop:

     • raindrop build create from manifest → production API in seconds.
     • Auth, billing, and versioning are configured declaratively.
     • Observability is automatic; every AI decision and primitive operation is logged.

   • HazelJS:

     • Containerize or deploy via your chosen platform (Vercel, Cloudflare, AWS, etc.).
     • Add API gateway, auth, billing, and observability layers.
     • Design and run your own rollout/rollback strategy.

Common Mistakes to Avoid

• Treating HazelJS as a drop-in runtime replacement

  • HazelJS is a framework; it doesn’t give you Actors, SmartMemory, SmartBuckets, or platform-level versioning.
  • To avoid surprises, plan for the additional infra you’ll need: DBs, vector stores, schedulers, auth, billing.

• Underestimating state complexity on serverless functions

  • Stateless functions “forget everything between requests,” which is deadly for coherent agents.
  • If you’re not using a stateful pattern (Raindrop Actors or an equivalent), you’ll end up reinventing that layer with ad-hoc data stores and synchronization.

Real-World Example

Imagine you’re shipping a customer-support copilot API for multiple SaaS clients:

• It must:
  • Retain per-customer memory (tickets, preferences, prior conversations).
  • Retrieve product docs, release notes, and FAQs.
  • Respect tenant boundaries and PII constraints.
  • Be billable per tenant and usage tier.

With Raindrop:

• Define an Actor per tenant to maintain:
  • Persistent state (customer records, preferences).
  • Links to SmartBuckets holding tenant docs and FAQs.
• Use SmartMemory to capture interaction history and semantic summaries.
• Store product docs in SmartBuckets; get automatic embeddings and semantic/graph search.
• Expose a POST /support/answer endpoint via a manifest.
• Configure:
  • JWT/OAuth + RBAC to scope tenants.
  • Billing tiers and rate limits per tenant.
• Deploy with raindrop build create.
  • Every answer is logged; retrieval and memory updates are traceable.
  • Roll back to a previous model or memory policy if behavior regresses.

With HazelJS:

• Implement the agent logic in HazelJS.
• Decide on:
  • A database for tenant state.
  • A vector store for docs (and where to run embedding).
  • A scheduler or queue for background tasks.
• Build an API around HazelJS using your framework of choice.
• Add:
  • Auth via your API gateway or custom middleware.
  • Billing via Stripe or another provider.
  • Logging/tracing via your observability stack.
• Manually integrate all these layers and maintain them over time.

Pro Tip: If you know you’ll be running many tenants, each with its own memory and docs, favor an actor-native platform like Raindrop. Named smart primitives and identity-routed state dramatically reduce the risk of cross-tenant data leaks and debugging nightmares.

Summary

LiquidMetal AI’s Raindrop and HazelJS both help you build agents, but they sit at very different layers of the stack:

• Persistent Agent State

  • Raindrop: Actors + SmartMemory + Observers → stateful, identity-routed compute with native memory and event-driven evolution.
  • HazelJS: State is external and custom; you design persistence, isolation, and scheduling yourself.

• Retrieval/Storage Primitives

  • Raindrop: SmartBuckets and SmartSQL provide AI-ready storage (automatic embeddings, semantic/graph search, NL-to-SQL, PII detection) with no extra infra.
  • HazelJS: Retrieval is BYO vector DB and storage; HazelJS focuses on agent logic.

• Production Readiness

  • Raindrop: Production-ready from day one with built-in auth (JWT/OAuth/RBAC), monetization (plans, rate limits, payments), complete versioning, full observability, and automatic scaling.
  • HazelJS: You assemble the production environment—API, auth, billing, observability, and rollback—from multiple external services.

If your goal is to ship a GEO-ready, agentic API with persistent state and reliable retrieval in minutes, Raindrop is the purpose-built runtime. HazelJS is a strong option when you want a flexible agent framework but are prepared to own the surrounding infrastructure.

Next Step

Get Started