GrowthPilot

A memory-first AI GTM teammate that researches, creates, measures, reflects, and improves every campaign with CockroachDB and AWS Bedrock.

Comment

https://github.com/cosmicoral/GrowthPilot-CockroachDB-X-AWS-Hackathon-2026

Inspiration

Early-stage founders repeatedly explain the same context to disconnected AI tools: who their customers are, how the product is positioned, what they published last week, what performed well, and what they want to try next. Most AI tools generate an answer but forget the reasoning and results behind it, so every new interaction starts from zero.

We built GrowthPilot to explore a different model: an AI go-to-market teammate with durable, inspectable memory. Instead of producing isolated outputs, GrowthPilot remembers company context, retrieves relevant past experience before acting, reflects on campaign performance, and uses those reflections to improve future work.

Our goal was to make the improvement loop visible:

Research → Create → Measure → Reflect → Remember → Improve

What it does

GrowthPilot helps a founder move through an end-to-end go-to-market workflow:

  1. Founder onboarding captures company positioning, ideal customers, goals, channels, and previous experiments as typed memories.
  2. A Market Research Agent turns company context into structured, reusable research findings.
  3. A Planner Agent routes requests to research, content, analytics, or memory-grounded Q&A.
  4. A Content Generation Agent retrieves relevant memories before creating marketing content.
  5. An Analytics & Reflection Agent compares simulated LinkedIn performance, identifies the strongest content theme, creates a cautious plain-language hypothesis, and saves it as a reflection memory.
  6. The next content run can retrieve that reflection and visibly show that it was based on previous learning.
  7. A Memory Inspector shows which memories were used, including their type, relevance, recency, and importance.
  8. An Agent Activity view makes execution traces, latency, outputs, and errors observable.
  9. GrowthGraph demonstrates privacy-safe learning across a synthetic multi-company cohort. It returns anonymized aggregate themes without exposing company IDs, founder names, memory IDs, or raw memory content.

For transparency, campaign likes, comments, and clicks in the demo are simulated. GrowthPilot does not claim a live LinkedIn integration.

How we built it

GrowthPilot uses a React and TypeScript frontend connected to a FastAPI backend.

We use CockroachDB Cloud as the durable memory and application data layer. Each memory contains:

  • a company-scoped identifier;
  • one of five memory types: user, semantic, episodic, task, or reflection;
  • structured JSONB provenance;
  • importance and recency information;
  • a 1024-dimensional vector embedding.

Amazon Titan Text Embeddings V2 on AWS Bedrock generates the memory embeddings. CockroachDB’s vector capabilities provide semantic candidate retrieval, after which GrowthPilot applies hybrid ranking using similarity, recency decay, and importance.

Claude Sonnet on AWS Bedrock powers planning, research synthesis, content generation, memory extraction, and reflection writing. Deterministic analytics are calculated in Python before the model receives the results, preventing the model from silently changing the winning group or inventing performance metrics.

Every application request is scoped by the authenticated company. CockroachDB constraints and tenant-prefixed keys reinforce isolation at the database level, while GrowthGraph operates only over a deterministic allowlisted synthetic cohort.

The chat interface uses Server-Sent Events to stream:

  • retrieved memory provenance;
  • response tokens;
  • completion metadata;
  • readable error events.

We also implemented secure company sessions, bounded and redacted agent traces, content-hash deduplication, CockroachDB transaction retry handling, and repeatable data-seeding scripts.

Challenges we ran into

The hardest challenge was integrating independently developed layers under a short hackathon deadline. The memory system, agents, API contracts, authentication, frontend, synthetic data, and deployment work were developed in parallel, so small differences in response shapes or assumptions could break the complete loop.

Multi-tenancy required particular care. Semantic retrieval is useful only if it never leaks another company’s memories. We enforced company scoping in application queries, database keys, foreign-key relationships, API authentication, and GrowthGraph’s response contract.

We also encountered an AWS regional quota issue: Titan Text Embeddings V2 had zero on-demand throughput in our original London region. We investigated available regional quotas and moved the Bedrock runtime plan to Paris, using Titan locally in eu-west-3 and the EU Claude inference profile for text generation.

Other challenges included:

  • preserving incremental SSE streaming during backend integration;
  • making seed scripts repeatable without paying for duplicate embeddings;
  • coordinating schema migrations on a shared CockroachDB cluster;
  • connecting seeded performance data to the authenticated frontend user;
  • showing memory provenance without overwhelming the user;
  • distinguishing query-level database activity from cloud control-plane audit events;
  • keeping synthetic demo data clearly labelled and separated from real product claims.

Accomplishments that we're proud of

We are proud that GrowthPilot demonstrates a complete and understandable memory loop rather than simply placing a chatbot in front of a database.

A founder can see:

Simulated campaign performance
→ deterministic analytics
→ a plain-language reflection
→ the reflection saved as durable memory
→ the next content run retrieving that reflection

We also built:

  • five typed categories of durable agent memory;
  • semantic retrieval and hybrid ranking in CockroachDB;
  • visible memory provenance under AI responses;
  • authenticated tenant isolation across the API and database;
  • agent orchestration supporting single, parallel, and dependent workflows;
  • privacy-safe cross-company aggregate insights;
  • trace observability with recursive secret redaction;
  • deterministic, idempotent demo and GrowthGraph datasets;
  • a responsive frontend covering onboarding, chat, research, content, analytics, memories, traces, and GrowthGraph.

The project was built by a distributed five-person team in a little over two weeks. We coordinated work through a shared Trello board, focused branches, pull requests, automated checks, explicit dependency notes, and cross-layer API discussions.

What we learned

We learned that useful AI memory is not simply a conversation transcript. It needs type, provenance, tenant ownership, recency, importance, retrieval quality, deduplication, and a clear reason for being written.

We also learned that agentic systems become much easier to trust when their internal loop is visible. Showing the retrieved memories and saved reflection makes the system’s behavior more understandable than presenting only a polished final answer.

CockroachDB allowed us to keep relational integrity, JSON metadata, transactional writes, multi-tenant application data, and vector retrieval in one durable system. AWS Bedrock gave us a consistent interface for both embedding generation and language-model reasoning, although regional model availability and quota planning need to be treated as architectural concerns from the beginning.

Finally, we learned that honest scope boundaries improve a demo. Simulated performance, synthetic cross-company data, and current integration limitations are explicitly identified rather than presented as production integrations.

What's next for GrowthPilot

Our next priorities are:

  • completing production deployment and end-to-end monitoring;
  • evaluating hybrid ranking with Hit@3 and mean reciprocal rank;
  • replacing simulated campaign metrics with consented live integrations;
  • adding richer source citations to research outputs;
  • introducing migration history and safer deployment automation;
  • expanding GrowthGraph while preserving strict privacy thresholds;
  • adding human approval workflows before publishing or external actions;
  • evaluating memory quality, usefulness, and forgetting strategies over longer periods.

The long-term vision is a trustworthy AI growth partner that does not merely generate more content, but learns from a founder’s real history and helps each future decision become better informed.

Built With

Share this project:

Updates