Compass

A compass, not a mirror: vocational discovery where every claim is backed by sealed evidence and no number about you ever comes from an AI.

Comment

Tagline

A compass, not a mirror: vocational discovery where every claim is backed by sealed evidence and no number about you ever comes from an AI.

Inspiration

Career and self-discovery tools all ship the same thing — a confident number. "Spatial reasoning: 68%." If a model produced that number, it is invented: not reproducible, not auditable, and it drifts the moment you flatter it. Over a claim about who a person is and where they should go, that is unacceptable. COMPASS began from a conviction: "what should I dedicate myself to" is not a personality verdict to be pronounced, it is a fit between the capabilities you have actually demonstrated and what a path requires — something you discover by experiment, not by rating yourself on a quiz. We set out to build a vocational partner that could never become a flattering mirror.

What it does

Starting is simple. You get a Compass ID (no email, no password), a built-in 60-second Quick Tour, and an interface that always shows you one single next step — so you begin in seconds and can stop anytime, nothing is lost. Choose your depth: a Calm guided path (the default), the Full dashboard to explore, or just chat with the multi-agent team. You never do everything at once — COMPASS always offers exactly one next action.

Under that simplicity, here is everything it does:

Two intake tests — two separate categories, each a validated model. Neither returns a verdict; a high score seeds a hypothesis to test.

  • Big Five — 50 questions. Broad personality traits (OCEAN), public-domain IPIP items, on a 1–5 scale.
  • RIASEC — 60 questions. Vocational interests (Holland's model), 60 original items we wrote ourselves (the model is free; our own items stay clear of proprietary tests), on a 1–5 scale.

Then the abductive cycle, step by step — every step is sealed and recorded in the audit chain:

  1. State two rival hypotheses about a capability — competing explanations, held alive at once.
  2. Bring in evidence — self-report, behavioral, outcome, or paste a life narrative and let the Extractor turn it into candidate signals (they arrive pending).
  3. Validate the evidence you agree with — only your validation makes it real; the model has no authority.
  4. Link validated evidence to a hypothesis — it only counts once linked.
  5. Recompute & reseal — the deterministic engine computes the integer 0–1000 index and seals it (SHA-256, hash-chained).
  6. Design a discriminating experiment — with its failure criterion written before you run it — and preregister it.
  7. Run it, record observations, and close it — the outcome becomes new evidence.
  8. Recompute to watch the index move; Narrate — Gemini puts the sealed state into words (flip the language and narrate again: the words change, the numbers and the seal do not).

And more:

  • Vocational fit: name a trajectory, or adopt an occupation from the O*NET 31.0 Database (12 occupations, CC BY 4.0), and see it requirement by requirement (MET / SUPPORTED / OPEN / AGAINST) — what the path requires vs. what your evidence shows.
  • Chat with a real multi-agent team (Google ADK), live — a Companion orchestrating an Analyst, an Activity Scout (Google Search) and a Reflector.
  • Your version vs. the record: a confrontation view surfaces where your self-perception and the sealed evidence disagree.
  • Calm mode, bilingual English / Spanish, multi-user with no login (each visitor gets their own isolated, sealed compass on Cloud Storage). Contradicting evidence weighs more than confirming, so it can never become a flattering mirror.

Every claim is backed by recorded, sealed evidence; every index is an integer 0–1000 computed with exact fractions (no float in the decision path), sealed with SHA-256 into an append-only, hash-chained ledger that verifies independently.

The autonomous layer: an agent that acts, not one that waits

Most AI waits for you to ask. COMPASS ships an Autopilot that doesn't.

The same multi-agent team you can chat with (a Companion orchestrating an Analyst, an Activity Scout, and a Reflector, built on Google ADK) also runs unattended in the background as a Cloud Run Job triggered by Cloud Scheduler. On a schedule, with no human in the room, it sweeps every user's compass and, for each one:

  1. reads the person's already-sealed state (read-only);
  2. names the deterministic capability gap worth testing next;
  3. drafts the next discriminating experiment (a preregistered design with a failure criterion written before it runs);
  4. searches the live web with Gemini + Google Search for concrete, grounded ways to actually run that experiment — a course, a community, an open project;
  5. puts the whole thing into words; and
  6. acts as a Sentinel, verifying the tamper-evident audit ledger (linkage · integrity · content) of every compass — so tampering is not merely detectable, it is actively watched, across the whole fleet, asynchronously.

The person wakes up to a ready-to-act briefing. The heavy lifting — gap analysis, web research, drafting, and fleet-wide ledger verification — already happened while they slept. This is the hackathon's thesis delivered literally: runs in the background, handles the heavy lifting, async.

The discipline that makes it trustworthy

Here is the part we are proudest of. It would have been easy to make the agent "autonomous" by letting it decide — validate your evidence, close your experiments, move your numbers. We refused. COMPASS's core invariant is that no number describing a person ever comes out of a language model; a deterministic engine computes and seals every index before any model speaks.

So the Autopilot's autonomy is over the heavy lifting, never over the decision. It proposes and it watches; it never validates evidence, links it, closes an experiment, or moves a single sealed number. Three mechanisms enforce that boundary:

  • By construction it holds no domain-write lever — it imports only sealed reads, the no-authority LLM roles, and the verifier.
  • By a fail-closed runtime guard: the seal and every index are snapshotted before and after each run; if anything moved, it raises AutopilotBoundaryError and refuses to persist — the architecture would be broken.
  • By storing its briefing beside the seal, never inside it: only a hash of the briefing enters the append-only chain, so the schema never changes and the already-deployed services keep serving unchanged.

A test locks this in: swap the model backend (Gemini ↔ offline) and only the wording of the briefing changes — never a verdict, a seal, or the chain of custody. That test is the thesis, now proven for the autonomous actor too.

Proof it runs on Google Cloud

  • Cloud Run Job: compass-autopilot (region us-central1, project vigia-497422) — batch, runs to completion, no public URL by design.
  • Cloud Scheduler: compass-autopilot-cron, ENABLED, daily.
  • Vertex AI: serves gemini-3.5-flash through the job's service identity (no API key stored).
  • Cloud Storage: each user's sealed SQLite base is restored, swept, and snapshotted back — the same bucket the live backend uses.
  • Reproduce it in one command: bash deploy/autopilot/deploy.sh; trigger a run with gcloud run jobs execute compass-autopilot. Full walkthrough in DEPLOY.md; code in src/compass/agent/autopilot.py.

How we built it

Two invariants drove every decision:

  1. No claim about the person exists without recorded, sealed evidence.
  2. No number describing the person ever comes out of an LLM.

A deterministic core (pure Python standard library) computes an integer 0–1000 index with fractions.Fraction — no floating point anywhere in the decision path — and seals it with SHA-256 over canonical, type-tagged, versioned bytes into an append-only, hash-chained ledger with an independent, stdlib-only verifier. Gemini 3.5 Flash on Vertex AI enters only as roles and agents with no authority: an extractor that proposes candidate signals, an abductor that proposes rival hypotheses, an experiment designer, a resource finder grounded with Google Search, and a narrator. The engine seals before any model is called, so the architecture test holds: swap the model and the wording changes — never a verdict, never a seal.

It runs entirely on Google Cloud: a Next.js web app, a FastAPI backend, and a separate Google ADK Web UI for the agent team, all on Cloud Run, with per-user isolated SQLite state snapshotted to Cloud Storage so each visitor gets their own compass that survives cold starts.

Challenges we ran into

Keeping the LLM genuinely out of the decision path is harder than it sounds — it is tempting to let a model "just tweak" a number. We enforced it as a test that fails if swapping the narrator backend changes any sealed value. Making determinism bit-exact meant banishing floats, canonicalizing serialization, and building an independent verifier. Designing for the intended audience meant a calm, one-step-at-a-time experience with a visible, gentle pending state on every model call — never a frozen wall.

Accomplishments that we're proud of

A vocational tool that can prove its claims. 184 tests pass, the audit chain verifies independently, and you can watch it live: POST /api/narrate runs real Gemini 3.5 Flash on Vertex and returns the exact same state seal it was given — the model changed the words, not a single sealed number. Real ADK multi-agent orchestration, and an architecture where the model proposes and narrates but the deterministic core decides and seals.

What we learned

That honesty is a feature. A documented ABSTAIN — "the evidence does not let me conclude" — is worth more than a confident wrong answer. And that anti-flattery, weighting contradiction over confirmation, is exactly what separates a compass from a mirror.

What's next for COMPASS

More validated, freely-usable instruments (RIASEC, O*NET-derived occupation requirements) feeding hypotheses; richer, cheaper discriminating experiments; and embedding the agent team directly into the main app so the whole cycle lives in one place.

Category: Collaborative Partner Try it (web app): https://compass-web-1028999311218.us-central1.run.app Try it (multi-agent chat, ADK): https://compass-agent-1028999311218.us-central1.run.app — pick compass_companion Repository: https://github.com/annatchijova/compass

▎ COMPASS makes real gemini-3.5-flash calls on Vertex AI (ADK). The deterministic core seals every index before the model is called, so Gemini narrates the result but never invents a number — swap the model and the wording changes, the sealed verdict doesn't. Not mocked: POST /api/narrate returns real, request-time Gemini prose with the state seal unchanged.

Built With

Share this project:

Updates

Submission history