Bounded Memory Core

Human-governed agent memory for scouting: specialist agents can plan together, but only adult-approved evidence becomes trusted memory.

Comment

Inspiration

Scout programmes involve safety checks, handovers, revisions, and decisions that should not disappear between meetings or leaders. Existing administration systems preserve official records, but future intelligent planning needs a different foundation: memory that remains useful without silently becoming trusted.

Bounded Memory Core explores that foundation. It is not a replacement for Scouts.Digital and does not connect to, scrape, or modify it. The prototype uses fictional troop data only and proves one carefully bounded planning workflow.

What it does

  1. Pathfinder extracts source-grounded requirements from supplied public guidance.
  2. Programme Builder turns that evidence and previously approved memory into a structured proposal.
  3. Duty Checker identifies support gaps and returns a clear question to the adult leader.
  4. The adult approves, rejects, or requests a revision.
  5. A revision creates an immutable linked child instead of overwriting history.
  6. Only approved relay events receive vectors and become eligible for later recall.
  7. Every recalled result exposes approval state, source provenance, model label, and similarity.

Rejected and revision-requested evidence remains persisted for accountability, but is excluded from trusted recall.

How we built it

The application is written in TypeScript and Node.js with a small same-origin web interface. One request handler serves both the local development server and the AWS Lambda Function URL.

CockroachDB Cloud is the persistent memory layer. Tasks, relay events, adult decisions, revision lineage, and 256-dimension embeddings are stored transactionally in the same database. A distributed cosine vector index powers recall, with SQL filters enforcing approval and embedding-model boundaries before results can be returned.

The second CockroachDB tool is Cloud Managed MCP. It is configured as a separate, cluster-scoped, read-only inspection path using only the mcp:read OAuth scope. It can inspect the live database, prototype tables, task schema, and aggregate task status without exposing application SQL credentials or row-level fictional records.

AWS Lambda provides the live Node.js 22 runtime and public same-origin interface. The deployment uses 256 MB memory, a 15-second timeout, buffered responses, and short CloudWatch log retention. The prototype uses deterministic embeddings by default so the memory mechanics can be demonstrated without a paid model call. An Amazon Titan Text Embeddings V2 adapter exists behind an explicit cost and permission gate, but Titan was not invoked and is not claimed as a completed integration.

CockroachDB tools used

Distributed Vector Indexing

Approved relay events are embedded into 256-dimension vectors and stored beside their operational records. A distributed cosine vector index retrieves matches, while the query also filters by approval state and embedding model. This keeps operational truth, provenance, approval, and recall consistent in one system.

CockroachDB Cloud Managed MCP Server

Managed MCP provides a separate judge-friendly and operator-friendly inspection path. The configured identity is restricted to the prototype cluster and the read-only mcp:read scope. We used it to verify the database, prototype tables, schema, and aggregate statuses without giving the MCP client application credentials or mutation rights.

AWS services used

AWS Lambda

Lambda hosts the complete bounded workflow and the web interface in us-east-1. The deployed handler serves health checks, the fictional planning flow, adult decisions, linked revisions, and approved-only recall against CockroachDB Cloud.

Amazon CloudWatch

Lambda execution logs provide deployment and invocation evidence. Retention is deliberately short for the prototype to limit cost and unnecessary data retention.

Challenges we ran into

  • Preserving rejected information for accountability without allowing it to influence trusted recall.
  • Carrying adult revision feedback forward without mutating the original agent history.
  • Giving judges operational visibility through Managed MCP without sharing SQL credentials or mutation permissions.
  • Deploying a public Lambda endpoint from a new AWS account with tight concurrency and cost constraints.
  • Demonstrating vector mechanics honestly while keeping the paid Bedrock path disabled until price and permissions were explicitly reviewed.

Accomplishments that we are proud of

  • A complete three-role agent relay with a visible adult gate.
  • Immutable linked revisions instead of silent overwrites.
  • Approved-only vector recall with source provenance and similarity.
  • Live CockroachDB persistence shared by the local and Lambda runtimes.
  • A least-privilege runtime SQL identity that can select, insert, and update but cannot delete or create schema objects.
  • A cluster-scoped, read-only Managed MCP inspection path.
  • Reproducible deployment, 14 automated tests, idempotent migrations, and verified negative paths.
  • A public-safe interface that uses fictional data and never touches real youth records.

What we learned

Agent memory is not just an embedding problem. The harder questions are who can promote evidence into trust, how revisions remain attributable, and how operators inspect the system without gaining accidental write access. CockroachDB made it possible to keep transactions, lineage, vectors, and policy filters together instead of splitting memory across inconsistent systems.

We also learned that a small deterministic model can be valuable when the purpose is to prove persistence, handoff contracts, and governance. Model quality can improve later; the approval boundary and audit trail need to be correct from the beginning.

What's next

  • Replace the deterministic relay logic with a permissioned Bedrock reasoning path while preserving the same contracts and adult gate.
  • Run the first explicitly approved Titan Text Embeddings V2 fixture and compare semantic retrieval quality.
  • Replace prototype network allowances with fixed, least-privilege production connectivity.
  • Add resilience tests, richer observability, and multi-programme evaluation.
  • Explore how this bounded memory core could support a future scouting operations layer without connecting it to official records until privacy, safeguarding, and governance requirements are satisfied.

Built With

Share this project:

Updates

Submission history