No Vector Database, an Agent Inventory, and a Browser Bot for the API That Never Existed

Three announcements landed within about 48 hours of each other this week, and each one is almost defiantly unglamorous. A Google product manager open-sourced a memory system that quietly throws out the vector database most RAG stacks are built on. Dataiku shipped a product whose entire job is finding AI agents an enterprise didn't know it had and ranking how dangerous each one is. And Strada, an insurance-vertical AI company, launched a feature that lets its agents click around inside decades-old carrier portals that never had an API to call. None of these move a benchmark. All three are about what happens after a chatbot stops being a demo and starts being infrastructure someone has to operate.

1. Memory Stops Being a Vector Database

A Google PM published Always On Memory Agent, an MIT-licensed reference implementation built on Google's Agent Development Kit and Gemini 3.1 Flash-Lite, and the detail that got it attention isn't a new capability — it's what it deliberately leaves out. There's no vector database and no embeddings step. Instead, the LLM itself reads incoming context, decides what's worth keeping, and writes structured memory straight into SQLite, with a consolidation pass every 30 minutes that summarizes and links what's accumulated so far. For a team that has been maintaining an embedding pipeline and a vector store just to give an agent a sense of "what happened last week," swapping that infrastructure for a scheduled LLM call and a single-file database is a real simplification, not just a smaller footprint.

// The shape Always On Memory Agent points at: no retrieval step,
// just an LLM that periodically re-reads and rewrites its own memory.
async function consolidateMemory(db: SqliteDb, recentEvents: Event[]) {
  const current = await db.get('memory'); // one row, not a similarity search
  const updated = await llm.complete({
    prompt: 'Merge these events into the existing memory. Keep it factual and short.',
    input: { current, recentEvents },
  });
  await db.set('memory', updated); // runs on a timer, not per query
}

It's a narrow pattern — fine for a single user's assistant, less obviously fine once memory has to be shared, searched, or scale past what an LLM can usefully re-read each cycle — but it's a legitimate default to reach for before reaching for a vector database, not after.

2. Someone Finally Has to Count the Agents

Dataiku's new Agent Management product, announced this week ahead of an October general release, does something almost embarrassingly overdue: it finds every agent an enterprise is running — across AWS Bedrock, Databricks, Vertex AI, Copilot Studio, Azure AI Foundry, Salesforce Agentforce, Snowflake Cortex, and anything else instrumented with OpenTelemetry — and puts them in one inventory. It then assigns each agent a risk tier based on how autonomous it is, how sensitive the data it touches is, and how much business impact a mistake would have, keeping a standing record of certification status and scheduled test runs for the highest-tier agents so the audit trail already exists before anyone asks for it.

The uncomfortable premise behind the product is the interesting part: most enterprises that have been standing up agents for the last year genuinely don't have a single list of them, built on different platforms by different teams, with no shared sense of which ones can actually do damage. That's the same governance gap security teams hit with unmanaged SaaS a decade ago, showing up again one layer up the stack, and it means agent inventory is quietly becoming its own product category rather than a feature of whichever platform built the agent.

3. Browser Automation for the Portal That Has No API

Strada's new capability is narrower but tells the same story from a different angle: its agents can now record a human's workflow once inside a web-based insurance carrier portal or legacy core system — no engineering required — and replay it against live data afterward, with every run logged start to finish for audit. Most of the systems Strada's agents need to touch, carrier portals, legacy TPA and MGA back ends, simply never shipped an API, and building one isn't Strada's call to make. Browser automation is the workaround: the agent operates the same web UI a human employee already has credentials for, and record-once-replay-many turns what used to be an integration project into something closer to macro recording, with a logged trail standing in for the audit guarantees an API would normally provide.

What Connects Them

None of this week's three announcements is chasing a smarter model. Google's memory agent is deciding where an agent's understanding of the world actually lives once a single context window can't hold it. Dataiku is deciding how an organization finds out how many agents it has before one of them causes a problem. Strada is deciding what an agent does when the system it needs to touch was never built to be touched by software at all. A chatbot that only answers questions in a single turn never needed any of this. An agent that has to remember, be accounted for, and act inside systems nobody re-engineered for it needs all three — and that's turning out to be most of the actual work.

Suggested visuals for this post: a side-by-side diagram contrasting a traditional embed-and-retrieve RAG pipeline against the read-consolidate-rewrite loop Always On Memory Agent uses; a mock agent-inventory dashboard showing agents color-coded by risk tier across five platforms; and a before/after pair showing a human clicking through a carrier portal versus Strada's recorded workflow replaying the same steps.

— Maya