Kawan

An animated accountability companion to keep you productive. Set one goal; Kawan fetches the evidence and verifies you actually did it. Judged privately on Chutes confidential AI.

Comment

Inspiration

Every productivity app has the same quiet flaw: it believes whatever you type. You say "done," it cheers, and nobody ever checked.

We kept watching the same story play out. Someone says "I'll ship it Friday," means it, and then no one checks. Friday comes, nothing shipped, guilt sets in, and the habit app gets deleted. Self-report is gameable, slacking costs nothing in the moment, and one broken streak ends the whole thing. Meanwhile, every AI "coach" just trusts what you tell it. We wanted the opposite of a cheerleader: a companion that checks, with real evidence, and earns the right to believe you.

What it does

Kawan is a voiced (coming soon), Live2D-animated accountability companion with a friendly but skeptical personality. You set one real commitment, and Kawan fetches the evidence itself to verify that you actually did it. It never takes your word, and it never does your work for you.

  • You compose one commitment in under a minute: a deliverable, a deadline, and a source of proof.
  • A living character interviews you, builds a personalized plan, and checks in on a cadence.
  • When you claim progress, Kawan fetches real evidence (a screenshot, a file, or a GitHub commit) and a multimodal model judges it in TEE (Trusted Environment Execution).
  • Verdicts are three-valued: pass, fail, or unclear. "Unclear" never punishes you.
  • A win seeds the next commitment; a miss routes to cheap recovery and a re-commit, so there is no streak to break.

The hard fields (deliverable, deadline, status, stakes) are user-only and audited. The AI writes exactly one thing: soft context. Kawan can never move the goalposts.

How we built it

Kawan is not just another chatbot wrapper. It is five role-specialized AI agents that each emit strict JSON, where structured output is the control plane that drives product logic, not just formatting: Intake (interviews you), Planner (roadmap), Check-in (cadence), Companion (the voice), and Evidence Judge (verdict plus confidence).

The stack is deliberately boring where it should be, and deep only where it counts:

  • Frontend: React 18 + Vite + TypeScript, a PixiJS + Live2D Cubism stage for the animated, voiced character (emotion drives expression and lip-sync), plus a PWA with Web Push.
  • Backend: a single-process FastAPI app, SQLAlchemy 2 async to Postgres on Supabase, and APScheduler for cadence, deadlines, and winbacks that rebuild from the database on boot. A WebSocket hub pushes live updates to the workspace.
  • Evidence connectors: GitHub REST, screenshot, and file.
  • The brain runs on Chutes. Every model call is confidential TEE inference with attestation and zero prompt logging, billed to the user's own balance through Sign in with Chutes. The judge is multimodal: a TEE vision model reads your screenshot and reasons about it.
  • Deploy: Vercel (frontend), Render (backend), Supabase (database). No external queue, nothing extra to break on stage.

Challenges we ran into

  • Keeping the AI on a leash. The hardest design problem was letting the AI be helpful without ever letting it change the goal. We split every commitment into hard fields (user-only, audited) and a single soft-context slot the AI may write, and the JSON schema enforces it.
  • Judging that stays honest under load. Real evidence judging can be slow when inference is busy. We made it degrade gracefully: a check that cannot complete returns "unclear" rather than a false "fail," because the iron rule is that uncertainty must never punish the user.

Accomplishments that we're proud of

  • A deep, judge-visible Chutes integration. Five touchpoints, all on the user's own confidential compute: TEE plus attestation (Intel TDX, zero prompt logging), structured outputs as the control plane, multimodal judging where a vision model reads the evidence, inline failover across the model pool (gemma-4-31B-turbo, DeepSeek-V3.2, Kimi-K2.6, all TEE), and Sign in with Chutes so each user funds their own inference. Privacy, billing, and product logic become one story.
  • An AI that genuinely cannot cheat for you. Hard fields are user-only and audited; the AI writes only soft context. The structure makes "never move the goalposts" a guarantee, not a promise.
  • A character that reacts to real outcomes. The Live2D companion drives expression and lip-sync from model emotion in real time, on a pinned runtime, instead of replaying canned animations.
  • A real end-to-end evidence loop, shipped and live. Compose, plan, check in, fetch evidence (screenshot, file, or GitHub), judge, and win, with three-valued verdicts that never punish uncertainty.

What we learned

  • Structured outputs are a product primitive, not a formatting trick. Treating JSON as the control plane let five small agents stay predictable.
  • Confidential TEE inference changes what you can promise a user. We could honestly say we cannot read their goals.
  • Designing an AI that refuses to do your work is a feature, not a limitation. The discipline of "process, scope, sequence, and time, but never the answer" is what makes the accountability real.
  • Multimodal judging needs explicit rules. Our judge once accepted a portfolio screenshot that still had placeholder text, correctly reasoning that placeholder copy is not grounds to fail an artifact that is clearly the promised deliverable.

What's next for Kawan

Monetary stakes, multi-commitment, a friend graph and leaderboard, and deeper retention. We also plan to integrate high quality TTS audio for each companion.

Built by Team CHJL with love for Chutes Hack Malaysia 2026. 💖

Built With

Share this project:

Updates

Submission history