ScopeLedger

• 

Inspiration

Client projects rarely fail because nobody took notes. They fail because important context gets scattered across meetings: what was agreed, what changed, which requests were approved, and whether the current deadline and budget still make sense.

I built ScopeLedger to give project teams a durable source of truth. Instead of treating meeting notes as static documents, ScopeLedger turns them into persistent project memory that can be queried, compared, and acted on.

What it does

ScopeLedger is an evidence-backed client delivery memory agent.

It converts meeting notes into structured memories such as:

• decisions and reasoning
• commitments and deadlines
• scope inclusions and exclusions
• pricing and deadline changes
• client preferences and expectations
• delivery risks and contradictions

It then uses those memories to reconstruct the current project state.

For example, ScopeLedger can detect when approved scope has increased while the project budget and deadline remain unchanged. Its Delivery Optimizer can then calculate practical options such as protecting the budget, protecting the deadline, or balancing additional capacity with a small schedule extension.

Users can also ask questions about project history using semantic search, such as:

Is mobile support part of the current release?

ScopeLedger retrieves the relevant project memories and answers from stored evidence rather than relying only on the current LLM conversation.

How we built it

ScopeLedger uses CockroachDB Cloud as the persistent memory layer.

Structured project data such as decisions, scope, commitments, evidence, budgets, and deadlines is stored relationally. Semantic memories are represented as embeddings and queried using CockroachDB Distributed Vector Indexing.

This gives ScopeLedger a hybrid retrieval model:

• SQL for precise project state
• vector search for semantic project history

We also integrated the CockroachDB Cloud Managed MCP Server as part of the CockroachDB toolchain.

On AWS:

• Amazon API Gateway exposes the application APIs
• AWS Lambda runs meeting ingestion, risk analysis, delivery optimization, and semantic retrieval

The frontend is built with Streamlit.

A key design decision was to separate raw evidence, extracted memories, and current project state. Historical statements remain auditable without every previous statement automatically becoming the current truth.

Challenges we ran into

One of the hardest problems was deciding what should be handled by an LLM and what should remain deterministic.

Risk explanations benefit from language reasoning, but delivery calculations such as capacity shortfalls, additional engineering cost, and schedule extensions need predictable logic. We therefore kept the Delivery Optimizer deterministic instead of asking an LLM to invent planning numbers.

Another challenge was handling repeated and conflicting memories. A project may contain several statements about the same deadline across multiple meetings. We needed to preserve those historical records while still identifying the current agreed deadline.

Semantic retrieval also required careful handling. Exact SQL queries are ideal for questions such as:

What is the current budget?

Vector search is more useful for questions such as:

What did the client previously say about mobile support?

Accomplishments that we're proud of

We are especially proud that ScopeLedger became more than a meeting summarizer.

It can:

• reconstruct current project state from multiple meetings
• distinguish approved scope from pending requests
• preserve evidence behind important decisions
• detect delivery constraints across project history
• perform semantic retrieval using CockroachDB vectors
• calculate concrete delivery options from stored project memory
• explain why a project has been flagged as high risk

The Delivery Optimizer became one of the strongest parts of the project because it turns memory into an actionable decision rather than simply generating another summary.

What we learned

We learned that useful agent memory is not just conversation history.

Different types of memory require different retrieval strategies. Deadlines, budgets, and approved scope need deterministic structured queries. Historical discussions and related context benefit from semantic retrieval.

We also learned the importance of provenance. An AI system becomes much more useful for project delivery when users can see not only a conclusion, but also the evidence that produced it.

Most importantly, we learned that an LLM does not need to control every part of an agentic application. Combining deterministic software with semantic reasoning produces a system that is easier to understand, verify, and trust.

What's next for ScopeLedger

There's a lot of room for ScopeLedger to improve on! What's great about the application is that its use case is not limited to project management, but it can be easily applied to other uses, such as lecture-notes analyzers, or to check lab notes.

Future improvements include:

• audio inputs
• stronger temporal memory and superseded-decision handling
• configurable delivery-cost and capacity models
• automated change-request generation
• project portfolio risk views
• notifications when new meetings create scope or deadline conflicts
• richer MCP-powered agent workflows
• role-based access and organization-level project isolation

The long-term goal is for ScopeLedger to become a persistent memory layer for client delivery: a system that always knows what was agreed, what changed, what remains unresolved, and what those changes mean for delivery.

Built With

• amazon-web-services
• api-gateway
• cloud
• lambda
• mcp
• postgresql
• python
• semantic
• serverless
• streamlit
• vector-indexing