Hive Call

Self-learning AI contact center that uses CockroachDB memory for known issues, stronger reasoning for novel ones, and turns every verified resolution into reusable capability.

Comment

Hive Call

The call center that learns from every resolved call

Most AI contact centers make the same economic mistake: they spend expensive reasoning on problems the company has already solved and on problems it has never seen before.

Hive Call separates those cases.

Known problems use learned organizational memory. Novel problems earn stronger reasoning. Problems that still require judgment go to a human. Every verified resolution can expand what the contact center handles through the cheaper path next time.

That is the product.

Progressive intelligence

Route When it runs What Hive Call does
Tier 1: Known territory A promoted skill safely matches the case CockroachDB retrieves the validated skill, Hive Call executes its bounded procedure against customer state, then Amazon Nova Micro (amazon.nova-micro-v1:0) receives only the verified facts and turns them into a natural customer response
Tier 2: Unknown territory No promoted skill safely applies Amazon Nova Pro (amazon.nova-pro-v1:0) receives targeted company context from CockroachDB, active policies, related verified cases, customer state, and typed tools so it can investigate the long tail
Tier 3: Human judgment Tier 2 cannot verify a safe resolution A human receives the conversation, tools already checked, evidence, relevant company context, and the exact reason for escalation

Tier 1 is deliberately not a zero-model path. Amazon Nova Micro is the conversational renderer, not the business reasoner. The business resolution has already been produced by a validated skill and deterministic tools. The model is constrained to the narrow verified context and is checked for unsupported amounts and dates before its answer is accepted.

Tier 2 is where Hive Call spends more intelligence. Amazon Nova Pro handles bounded reasoning, tool use, and candidate-skill compilation for cases the organization has not already learned.

The principle is simple:

Spend intelligence only where the company has not already learned the answer.

The learning loop

A successful Tier 2 or human resolution is not left behind as a transcript.

Hive Call turns it into a reusable support capability:

verified resolution -> candidate skill -> shadow execution -> policy/evidence checks -> transactional promotion -> future Tier 1

The reusable object is not a cached answer. It is a bounded declarative skill containing:

  • applicability conditions;
  • required customer and company context;
  • typed tool steps;
  • deterministic computations and assertions;
  • policy dependencies;
  • response facts the conversational model is allowed to communicate;
  • escalation conditions;
  • source-case lineage;
  • evaluation and promotion history.

Generated arbitrary code is never executed. A model may propose a candidate skill, but it cannot promote its own output.

A customer hanging up is not proof that an answer was correct. Hive Call only promotes a skill after the procedure itself executes against shadow cases and passes the required oracle, policy, and evidence checks.

Guided demo

The submitted demo uses fictional Northstar Commerce support data and four calls.

Call A: known territory

A customer asks about a late shipment.

Hive Call retrieves an existing promoted skill from CockroachDB, executes the known procedure, produces verified facts, and sends only those narrow facts to Amazon Nova Micro for the natural response.

Full reasoning-model calls: 0
Human escalation: 0

Call B: novel but solvable

A customer asks why a $60 item produced only a $43 refund.

No promoted skill safely applies, so Hive Call routes to Tier 2. Amazon Nova Pro receives the relevant order, refund, promotion, policy, company context, and typed tools, then resolves the case.

The verified trace becomes a candidate skill. The candidate executes against six shadow cases, is checked for policy behavior, and is promoted only if the procedure passes.

Call C: human judgment

A customer has a partial bundle return paid across mixed tender and the refund looks wrong.

Tier 1 has no safe match. Amazon Nova Pro investigates but cannot verify a safe resolution within its policy boundary, so Hive Call transfers the case to a human.

The human receives what Hive Call already checked instead of starting from zero. The verified human resolution is compiled into another candidate skill and goes through the same validation pipeline.

Call D: the payoff

A new customer presents a differently worded instance of the problem class learned in Call C.

CockroachDB retrieves the newly promoted skill, the applicability and policy checks pass, and the new call now resolves through Tier 1 using Amazon Nova Micro.

Previously required human judgment
Now resolved from learned memory
Full reasoning-model calls: 0
Human escalation: 0

The contact center learned a capability during the demo, persisted it, and reused it on a later call.

How CockroachDB powers Hive Call

CockroachDB is not a transcript store attached to the side of the agent. It is the authoritative persistent memory layer that changes how future calls execute.

Hive Call uses CockroachDB for two complementary kinds of memory.

1. Learned resolution memory

CockroachDB stores the procedures the organization has already learned how to execute safely:

  • candidate, promoted, degraded, deprecated, rejected, and superseded skill versions;
  • source calls and verified resolutions;
  • tool traces and outcome evidence;
  • policy dependencies and policy versions;
  • shadow evaluations;
  • promotion and demotion events;
  • model and token telemetry;
  • memory reads and audit lineage.

Tier 1 depends on this memory. A skill is only eligible when it is promoted, tenant-compatible, policy-compatible, and applicable to the current case.

2. Company context memory

CockroachDB also stores the context Tier 2 needs to understand how the business actually works, including product information, plans, billing rules, refund policies, procedures, documentation, customer state, and related verified cases.

Amazon Nova Pro does not receive the entire company database. Hive Call retrieves only the context relevant to the current problem.

Distributed Vector Indexing

Calls, learned skills, and company context use real VECTOR(1024) embeddings. The deployed schema contains three distributed vector indexes:

  • skill_embedding_idx for learned skill retrieval;
  • call_embedding_idx for semantically related calls and cases;
  • company_context_embedding_idx for targeted company-context retrieval.

Embeddings are generated with Amazon Titan Text Embeddings V2 (amazon.titan-embed-text-v2:0).

Vector similarity is only the first stage. A semantically similar skill is not automatically allowed to execute. Retrieval is followed by structured checks for tenant, promotion status, policy compatibility, required context, and applicability.

This deliberately biases Tier 1 toward precision. A missed match costs a Nova Pro reasoning call. A false match can produce the wrong customer answer.

CockroachDB Cloud Managed MCP Server

Hive Call also uses the CockroachDB Cloud Managed MCP Server as a separate read-only inspection path for the live organizational memory.

The application persists Managed MCP evidence so System Proof can demonstrate the memory independently from the normal application query path. The separate Lambda-side MCP proxy remains intentionally unclaimed because only the independently verified Managed MCP lookup is treated as proof.

Transactional learning

Many calls can complete concurrently and propose overlapping skills. Promotion, supersession, demotion, and resolution finalization therefore use retryable transactional and idempotent CockroachDB writes.

This keeps the learning layer consistent even when multiple workers try to update organizational memory at the same time.

How AWS powers Hive Call

AWS is the execution environment for the deployed contact-center system.

AWS service Exact role in Hive Call
Amazon Bedrock, Amazon Nova Micro Tier 1 conversational renderer. Exact model ID: amazon.nova-micro-v1:0. Receives only the selected promoted skill, verified facts, authoritative resolution, current customer issue, and response constraints
Amazon Bedrock, Amazon Nova Pro Tier 2 reasoning, structured tool use, and bounded skill compilation. Exact model ID: amazon.nova-pro-v1:0
Amazon Titan Text Embeddings V2 Creates 1024-dimensional embeddings for calls, skills, and company context. Exact model ID: amazon.titan-embed-text-v2:0
Amazon Polly Generates customer-facing voice using the Ruth voice with the generative engine
AWS Lambda Runs the deployed Next.js API and agent workflows
Amazon API Gateway Exposes the public functional application and API surface
Amazon S3 Stores sanitized, content-addressed voice artifacts privately with encryption and lifecycle expiry
Amazon CloudWatch Runtime logs, model/token metrics, latency, escalation metrics, rate-limit events, alarms, and dashboarding
AWS Secrets Manager Holds external database and MCP credentials outside the codebase

The important design choice is that Bedrock is not given the same reasoning budget for every call.

Known territory: CockroachDB skill memory + deterministic execution + Amazon Nova Micro.
Unknown territory: targeted CockroachDB company context + Amazon Nova Pro.
Unsafe or ambiguous territory: human judgment.

As Hive Call learns, repeated problem classes can move from Human -> Nova Pro reasoning -> learned Tier 1 memory.

System architecture

Customer call
     |
     v
CockroachDB memory search
     |
     +-----------------------------+
     |                             |
Promoted skill found          No safe skill
     |                             |
     v                             v
Tier 1                       Tier 2
Nova Micro                   Nova Pro
narrow verified context      targeted company context
     |                             |
     |                        solved safely?
     |                         /        \
     |                       yes         no
     |                        |           |
     |                        |           v
     |                        |         Human
     |                        |           |
     +------------------------+-----------+
                              |
                              v
                      Verified resolution
                              |
                              v
                        Skill compiler
                              |
                              v
                        Candidate skill
                              |
                              v
                      Shadow validation
                              |
                        pass / reject
                              |
                              v
                         CockroachDB
                    relational + vector memory
                              |
                              +----> future Tier 1 call

Production boundaries

A self-learning system can get worse if it memorizes bad work, so Hive Call is designed to fail closed rather than maximize automation coverage.

Current controls include:

  • only promoted skills can execute through Tier 1;
  • generated skills must conform to a typed schema and bounded declarative DSL;
  • shadow validation executes the proposed procedure rather than simply matching similar fixtures;
  • oracle-fact and policy assertions verify expected behavior;
  • Nova Micro output is checked against authoritative Tier 1 facts;
  • policy versions are linked to learned skills;
  • degraded skills are removed from Tier 1;
  • promotion and finalization are transactional and idempotent;
  • runtime-reader and reviewer APIs use separate roles;
  • unauthenticated protected memory access is rejected;
  • Bedrock and Titan calls use bounded timeouts;
  • expensive public demo routes use CockroachDB-backed rate limits in addition to API Gateway throttling;
  • Polly audio is reused from private S3 instead of being regenerated unnecessarily;
  • CloudWatch records requests, model calls and tokens, latency, human escalation, and full-reasoning avoidance.

Hive Call does not claim every support case should become autonomous. Fraud, policy exceptions, high-impact decisions, and ambiguous cases can remain human work.

The goal is narrower:

Do not spend expensive reasoning or repeated human effort on a problem the organization has already learned, validated, and can safely execute.

What is different

A knowledge base remembers information.

Transcript search remembers conversations.

A standard AI support agent reasons about the current request.

Hive Call remembers how a verified problem was resolved, when that resolution is valid, what evidence supports it, and how a future agent can execute it safely.

That changes the economics of the system without retraining the foundation model.

Scope and limitations

This submission uses fictional Northstar Commerce customer, order, shipment, promotion, subscription, and refund data.

The web experience simulates a contact-center call flow and human handoff. It does not claim production telephony integration, real customer deployment, measured dollar savings, or 99% autonomous coverage.

The submitted result is the learning loop itself:

resolve once, validate the procedure, persist it in CockroachDB, and let the next agent spend less intelligence solving it.

Built with

CockroachDB Cloud, CockroachDB Distributed Vector Indexing, CockroachDB Cloud Managed MCP Server, Amazon Bedrock, Amazon Nova Micro, Amazon Nova Pro, Amazon Titan Text Embeddings V2, AWS Lambda, Amazon Polly, Amazon S3, Amazon API Gateway, Amazon CloudWatch, AWS Secrets Manager, AWS CDK, Next.js 16, React, TypeScript, Zod, SQL, and vector search.

Live demo

https://h0yzyuck8i.execute-api.us-east-1.amazonaws.com/demo

Built With

Share this project:

Updates

Submission history