Isolyne: Radar for Silent Team Drift

Isolyne is a mobile radar that catches teammates building on contradictory decisions and buzzes every phone. Code judges, not LLMs. Free drift alerts; Pro unlocks your decision timeline.

Comment

Inspiration

Hackathon teams don't fail because they write bad code. They fail because of the illusion of agreement.

Around hour 30 of a sprint, someone goes AFK to sleep or eat. One dev wires up Firebase. The other defines the schema in Postgres. Both said "sounds good" in chat. Neither finds out until 3 AM on Sunday, when integration hell arrives with no time left to survive it.

The tools we already have don't fix this. Slack and Discord bury decisions under memes and panic. Jira is too heavy, because nobody moves tickets in a 48-hour sprint. We wanted a truth beacon in your pocket that costs nothing to feed, ignores chat noise, and tells you the second your team's reality splits.

What it does

Isolyne is an automated architectural referee for teams that move too fast to argue.

  1. Log casually. Type what you're doing, like "Setting up Zustand for state." No tickets, no forms. Our rule is Zero Double-Logging.
  2. Detect deterministically. Every new statement is checked against the team's entire established decision tree.
  3. Feel the alert. On a contradiction, a full-screen red Radar Alert fires with distinct haptics for alignment versus divergence.
  4. Resolve from your phone. Agree, challenge, or claim ownership, and the diverging branches merge back into one shared reality.

Five kinds of drift it catches

  • Consensus: two devs choose different tech for the same topic.
  • Interpretation: teammates define a feature's scope differently.
  • Ownership: two people claim the same component.
  • Timeline: disagreement about when something gets built.
  • Execution: one says "done," another says "still working."

How we built it

The most important thing about Isolyne is what it refuses to do: it never asks an LLM to judge whether your team is aligned.

Layer 1: LLM extraction, strictly sandboxed

Groq (Llama 3) turns casual text into strict structured data, such as topic: "database" and choice: "Postgres". If Groq fails, Gemini takes over. If that fails, a fully offline keyword parser keeps the app working with no network. The model parses and nothing else.

Layer 2: a deterministic CQRS event-sourced kernel

All judgment happens in pure TypeScript with no model in the loop. Every input flows through one pipeline:

Signal → AwarenessGap → DecisionProposal → Commitment → CollaborationMemory

This gives us reproducible verdicts, an immutable and auditable timeline, and zero hallucinated conflicts. A radar that cries wolf gets muted, so a false alarm would kill the product.

The stack

React Native with Expo SDK 57 (New Architecture), Expo Router, Reanimated physics animations, expo-blur glassmorphism, expo-haptics, AsyncStorage-backed offline-first persistence, a custom React Context wrapping the kernel, and RevenueCat for entitlements and paywalls. The design language is brutalist dark mode (#07080F) with Orbitron headers and monospace logs.

Challenges we ran into

  • Keeping the LLM out of the verdict. It's tempting to ask a model "do these two statements disagree?" We drew a hard line instead: models parse, code decides.
  • Gaps that resolve themselves. If Anu changes her mind and aligns with Abhi before anyone formally resolves the conflict, the alert should vanish. We built these "evaporating gaps" into the state machine and tested the edge cases explicitly.
  • Hostile conditions. Hackathon Wi-Fi is unreliable, so parsing degrades across three tiers and logging is never blocked.
  • Alerts that mean something. The haptics and visuals had to be loud enough to wake someone mid-nap without turning into noise.

Accomplishments that we're proud of

  • A fully deterministic kernel with 72 passing Vitest tests, including the hard state-machine edge cases.
  • An architecture where the AI can fail completely and the product still works.
  • A paywall placed at a moment of real emotional value instead of buried in settings.
  • A demo that hooks in seconds: the app boots straight into a live conflict.

What we learned

  • Trust in a coordination tool comes from predictability, and determinism beats cleverness here.
  • The best time to ask for money is right after the product has just earned it.
  • Writing about each decision in public forced us to defend it.

Monetization: the "Moment of Doubt" (HAMM Award)

We didn't bolt a subscription onto a random feature. We designed the paywall around one specific emotion.

  • Free forever: unlimited real-time drift detection and alerts. The core value is never walled off, so teams trust it and adopt it.
  • The trigger: a team resolves a serious conflict, the kind that would have wrecked their sprint. That is the Moment of Doubt: relief, plus the realization that the app just saved them.
  • The paywall: at exactly that moment, Isolyne Pro offers the full immutable decision timeline and its export. Free users see only the most recent events. Pro users get the complete record, formatted to attach to a Devpost post-mortem as proof of engineering rigor.

The paywall appears when perceived value peaks, and it sells something the user immediately wants: evidence to show judges. RevenueCat handles purchases and entitlements through the React Native Purchases SDK, keeping free and Pro states in sync with the kernel's timeline gating.

Built by the next generation (Next Gen Award)

Isolyne is built by students using the toolchain of a seasoned team: Expo SDK 57 on the New Architecture, strict TypeScript, Reanimated 4, an event-sourced CQRS core, a three-tier LLM fallback chain, and a 72-test suite. We treated a hackathon app like production software. The part we're proudest of is the architectural restraint of keeping AI out of the decision loop.

Built in public

We documented the build instead of waiting for launch. Our HackerNoon stories cover our architectural decisions, UI iterations, and hackathon progress as they happened, so the problem was validated with real developers before the app shipped.

A note on the demo

To make the alert instantly visible, the demo loads a scripted scenario: five aligned decisions, then Abhi logging "Firebase" while Anu logs "PostgreSQL." The detection and resolution that follow run on the real kernel.

What's next

  • Team sync across devices, so one team shares one live radar.
  • Capturing decisions from commits and PR descriptions.
  • Expanding beyond hackathons to early-stage startups and any small team that outpaces its process.

Built With

  • async-storage
  • cqrs
  • event-sourcing
  • expo-blur
  • expo-haptics
  • expo-linear-gradient
  • expo-router
  • expo.io
  • google-gemini
  • groq
  • llama-3
  • react-context
  • react-native
  • react-native-reanimated
  • revenuecat
  • typescript
  • vitest
Share this project:

Updates

Submission history