CountOn

CountOn gives Alexa a new superpower: knowing when real life breaks your expectations.

Comment

Inspiration

We realized something about Alexa:

It remembers commands, but not necessarily the things we casually say we’re counting on.

“My package should arrive Friday.”
“The plumber said he’ll come tomorrow.”
“My next electricity bill should stay under $150.”

These aren't reminders. They're expectations.

Today, we repeatedly check emails, calendars, bills, delivery pages, and messages to find out whether those expectations actually happened.

CountOn turns those passing expectations into something Alexa can quietly watch for you.

Our product principle:

Silence is success.

If everything goes according to plan, CountOn does nothing.

What it does

CountOn converts natural language into a monitored expectation:

Expectation → Evidence → Evaluation → Exception

Every expectation ends in one of three deterministic states:

  • MATCH — reality matched the expectation. Stay quiet.
  • UNKNOWN — not enough evidence yet. Keep watching.
  • MISMATCH — reality broke the expectation. Notify and explain.

Example:

You: “My electricity bill should stay under $150.”
Evidence: New bill = $180
CountOn: MISMATCH → “Your bill is $30 above the limit you set.”

The key distinction:

AI understands. CountOn decides.

The LLM never gets to invent MATCH, UNKNOWN, or MISMATCH.

How we built it

Architecture

          Alexa                Web
             │                  │
             └───────┬──────────┘
                     ↓
             Trust Orchestrator
                     │
                     ↓
                  MCP Layer
        ┌────────────┼────────────┐
        ↓            ↓            ↓
     Compile       Capture      Explain
        │            │            │
        └────────────┼────────────┘
                     ↓
              CountOn Backend
                     │
          ┌──────────┴──────────┐
          ↓                     ↓
      Evidence              PostgreSQL
          │                  / Supabase
          ↓
   Deterministic Evaluator
          │
     ┌────┼─────┐
     ↓    ↓     ↓
   MATCH UNKNOWN MISMATCH
                  │
                  ↓
             Bedrock
        Grounded explanation

Our MCP server is self-hosted over Streamable HTTP and provides a controlled capability surface for the Alexa+ experience.

Core stack

  • Amazon Alexa — conversational interface
  • Amazon Bedrock — natural-language compilation, clarification, explanation
  • MCP — controlled capability/action layer
  • FastAPI / Python — backend and deterministic evaluation
  • Supabase + PostgreSQL — shared persisted state
  • Web dashboard — expectations, evidence, status, and activity

MCP capabilities

We intentionally expose a small tool surface:

  • Compile an expectation
  • Continue clarification
  • Capture an expectation
  • List expectations
  • Retrieve an expectation
  • Explain a mismatch

Alexa and the web app use the same backend and persisted expectation objects.

Why the architecture matters

We deliberately did not build:

Evidence → LLM → "I think this succeeded"

Instead:

Human language
      ↓
     AI
      ↓
Structured expectation
      ↓
Evidence
      ↓
Deterministic code
      ↓
MATCH / UNKNOWN / MISMATCH

Bedrock handles ambiguity.

CountOn handles truth.

This makes results:

  • reproducible
  • testable
  • auditable
  • grounded in evidence
  • safer for proactive AI

Challenges we ran into

1. What actually counts as proof?

“The plumber will arrive Friday.”

This proves a commitment.

It does not prove the plumber arrived.

That is why UNKNOWN became just as important as MATCH and MISMATCH.

2. Preventing AI from becoming the source of truth

The easiest implementation was:

“Here is the evidence. LLM, did it happen?”

We rejected that architecture.

AI interprets language and explains results, but deterministic application logic decides the outcome.

3. Making Alexa and the web one product

We did not want:

Alexa system ≠ Web system

Instead:

Alexa ─┐
       ├── Same expectations
Web ───┘   Same evidence
           Same evaluator
           Same database

An expectation created conversationally can appear in the dashboard with the same lifecycle and history.

4. Real-world integrations

Email, calendars, commerce systems, and smart-home devices each introduce OAuth, permissions, APIs, hardware, and account-linking complexity.

For sources we could not safely complete during the hackathon, we use clearly labeled simulators for evidence generation.

The expectation lifecycle, persistence, deterministic evaluation, and MATCH / UNKNOWN / MISMATCH result generation still run through the real CountOn backend.

Accomplishments that we're proud of

CountOn is more than an LLM wrapper.

We built:

  • a deterministic expectation evaluator
  • MATCH / UNKNOWN / MISMATCH semantics
  • shared Alexa + web state
  • a controlled MCP capability layer
  • evidence provenance
  • persisted expectation lifecycle
  • grounded Bedrock explanations
  • authorization and trust boundaries
  • simulated evidence without simulated conclusions

Most importantly:

We designed a proactive AI system that knows when not to speak.

What we learned

Proactive AI needs a stronger trust model than chat AI.

When a chatbot is wrong, you can ask another question.

When an assistant is monitoring your life and deciding when to interrupt you, uncertainty becomes much more important.

We learned that:

  • LLMs are excellent at language.
  • Deterministic systems are better at truth conditions.
  • Provenance matters as much as the evidence itself.
  • UNKNOWN is a feature, not a failure.
  • Good proactive AI should reduce attention, not demand more of it.

What's next for CountOn

The bigger vision is an expectation layer for Alexa.

Today:

“My package should arrive Friday.”

Tomorrow:

“Only tell me if it hasn't shipped by Thursday and is still supposed to arrive Friday.”

Or:

“Make sure this subscription stays below $20 unless I approve a price increase.”

Potential evidence sources include:

  • Email
  • Calendars
  • Commerce and delivery updates
  • Bills
  • Smart-home events
  • App notifications
  • User-authorized services

The next production step is deeper user-authorized connectivity across these sources while keeping the same deterministic trust model.

The goal isn't to make Alexa talk more.

It's to make Alexa understand what matters enough that you no longer have to keep checking.

You say it once. CountOn watches what happens next.

Built With

Share this project:

Updates

Submission history