Kawan is a skeptical accountability companion. It holds you to one commitment, asks for real evidence, and only believes you once you've shown it, judged by models on Chutes. Sign in with Chutes, and every call bills to your own Chutes account.
Live Demo → · Demo Video · Source Code

Try it
- Open kawan-frontend.vercel.app and choose Sign in with Chutes, so inference runs on your own Chutes account, or Continue as guest, which runs on the team's key in one account every guest shares.
- The guided tour at
/welcomewalks through a demo commitment: Commitments, Create, Workspace, Details, and Analytics. - To try one of your own, compose a commitment, answer Kawan's intake questions, and submit evidence: a screenshot, a file, or a public GitHub repo.
Inspiration
"It doesn't believe you. Yet." A to-do app takes "done" on trust, and a coach that only cheers has nothing to check. Kawan is the opposite of a cheerleader: one commitment, a deadline, and a source of proof, and a companion that looks at the proof itself before it believes you.
Who it's for
Students and professionals with one deliverable that matters, a deadline, and nobody checking whether it's really done: the examples Kawan offers are a landing page, a thesis chapter, a grant application, and an auth refactor. A to-do list takes their word for it; Kawan asks for the proof.
What it does
You set one commitment: what you'll deliver, by when, and how Kawan can check. A Live2D character interviews you about it, writes a plan, and checks in on a schedule. When you claim progress, Kawan fetches or receives the evidence and a model on Chutes judges it: Evidence accepted, Not accepted, or Needs more context.
Features
- Compose: a 3-step wizard for the deliverable and deadline, the plan and its terms, and your companion. An optional GitHub repo to check, an optional witness to tell if you miss, and a reminder email. At most 3 commitments are in flight at once.
- Intake: the companion asks visual-novel style, with options or free text, until it knows four things: why, obstacles, your time, and your skill.
- Plan: a roadmap of steps with estimated minutes, written once intake is done.
- Workspace: chat with your companion. It coaches, refuses to do the work for you, or proposes a change, which you apply or dismiss.
- Check-ins: on demand, or on a schedule: daily for a commitment of a day or more, one midpoint nudge for a shorter one. Reminders arrive by Web Push, email, or Telegram.
- Evidence: a screenshot or a file up to 8 MB, or a public GitHub repo, whose recent commits Kawan fetches itself: the titles and sizes of up to 5 that change 3 or more lines.
- Recovery, not streaks: escalating check-ins, a single win-back message after two silent ones, and a debrief after the outcome.
- Three companions: Kawan, Adik, and Cik Maid, Live2D characters whose expression follows the emotion the model returns.
- Your record: achievements, identity titles at 1, 3, 5, and 10 wins, a shareable win card, an audit history, and delete-my-data.
How it works
1. Make your commitment: what you'll deliver, and by when.

2. Set the terms: a GitHub repo to check, a witness if you miss, and a reminder email.

3. Choose your companion: Kawan, Adik, or Cik Maid.

4. Talk it through. Your companion interviews you, then checks in on the schedule.

5. Work in the workspace, with your context, plan, and activity beside the chat, and Check in or Finish early when you have proof.

6. Show the evidence. The commitment's page holds its progress, evidence, and verdicts, until it's done.


Screenshots
| Screen | What it shows |
|---|---|
| Landing | "It doesn't believe you. Yet." |
| Sign in | Sign in with Chutes, or continue as a guest |
| Home | Your commitment, workspace, analytics, and recent activity |
| Commitments | Every commitment and its status |
| Analytics | Stat cards, charts, and achievements, with no streaks |
| Guided tour | The /welcome walkthrough |
Use of Chutes
Chutes runs every agent's chat and every evidence judgment. The one exception is a fallback: if a Chutes call fails on evidence you submit, a Gemini model judges it instead, so that evidence leaves Chutes.
| Chutes feature | Where | What Kawan does with it |
|---|---|---|
Chat completions, llm.chutes.ai/v1 |
apps/backend/app/chutes.py |
Every agent's turn, with a 90-second timeout, one token refresh on a 401, and up to 2 retries on a 5xx |
| TEE models | apps/backend/app/personas.py, app/prompts.py |
google/gemma-4-31B-turbo-TEE, deepseek-ai/DeepSeek-V3.2-TEE, and moonshotai/Kimi-K2.6-TEE, one lead model per companion |
| Model failover | app/chutes.py |
Each chat and text-judge request names a lead model and its fallbacks, comma-joined, for Chutes to fail over; the vision judge uses gemma only |
| JSON output | app/chutes.py, app/prompts.py |
Each agent's schema is in its prompt, with response_format: json_object, and the reply is parsed in code |
| Vision | app/adapters/screenshot.py |
A screenshot goes to gemma-4-31B-turbo-TEE as an image, and is never stored |
| Sign in with Chutes | app/auth.py |
OAuth 2 with PKCE and the scopes openid profile chutes:invoke. Each signed-in user's own token makes their calls, so inference bills to their Chutes balance, which Kawan shows in the account menu and Settings. Tokens are stored encrypted and refreshed a minute before they expire |
| Model catalog | scripts/smoke_chutes.py (repo root) |
Run by hand before launch, against the live catalog: every model exists and supports structured outputs, the judges run on confidential compute, and the vision judge takes images |
Five agents, one rule. Each agent answers in JSON, and its output drives product logic:
| Agent | Returns | What it drives |
|---|---|---|
| Intake | What to say, and four slots: why, obstacles, time, skill | Fills only empty slots; code decides when intake is complete |
| Planner | A roadmap of ordered steps with estimated minutes | The plan, shown for reference |
| Check-in | What to say, and an emotion | The check-in message and the companion's expression |
| Workspace coach | Coaching, a refusal, or a proposal | A proposal is only a card the user applies or dismisses |
| Evidence judge | A verdict, confidence, observations, and what to show next | The commitment's outcome |
The AI can't move the goalposts. The deliverable, deadline, and stakes are hard fields that change only when the user edits them or applies a proposal; status changes only through the state machine. Every change is audited with its actor, and the database rejects any actor but the user or the system. The AI writes only soft context.
Sign in with Chutes makes it the user's own. A signed-in user's companion, plans, check-ins, and verdicts all run on their own Chutes token and balance, so the team doesn't pay for their inference, and Kawan never needs a password of its own.
How we built it
Architecture
Made with Archify.
- Frontend: a React SPA on Vercel, which forwards
/api/*to the backend. - Backend: one FastAPI process on Render, with SQLAlchemy async on Supabase Postgres.
- Scheduler: APScheduler, in process, for cadence, deadlines, win-backs, and grace windows, rebuilt from the database on boot.
- Check-in pipeline: evidence adapters fetch the proof, the judge on Chutes rules on it, and state code applies the outcome.
- Delivery: Web Push, email through Resend, Telegram, and the in-app timeline.
Tech stack
- Frontend: React 18, React Router 7, Vite 8, TypeScript, Tailwind CSS 4, PixiJS with
pixi-live2d-display, Motion, Recharts - Backend: Python 3.12, FastAPI, SQLAlchemy 2 async, asyncpg, APScheduler, Pydantic Settings, httpx, pywebpush, pypdf, python-docx
- Inference: Chutes, with Sign in with Chutes
- Tests: about 270 pytest tests on in-memory SQLite
Challenges we ran into
- Strict schemas broke decoding on these models. So each schema goes in the prompt instead, the request asks for a JSON object, and a parser strips thinking blocks and code fences before it parses the reply.
- A slow judge mustn't fail you. A stalled vision call once hung an evidence check for over two minutes. Now, for evidence you submit, the judge has 60 seconds; if the Chutes call fails, a Gemini fallback judges the screenshot or text, and if that fails too, the verdict is a neutral "unclear", never a "fail". Scheduled checks don't have this guard yet.
- Letting the AI help without letting it decide. Hard fields, an audited actor on every change, and a database check keep every commitment's terms with the user.
Accomplishments that we're proud of
- A full loop: compose, intake, plan, check in, fetch evidence, judge, and an outcome, with recovery instead of a streak to break.
- Inference the user pays for. Sign in with Chutes makes each signed-in user's calls on their own balance, so the app can grow without the team paying for everyone's inference.
- Three verdicts, honestly worded. Mid-commitment, "Needs more context" only asks for more proof instead of failing you.
- Tested rules. About 270 backend tests, including one that rejects an AI actor in the audit log.
What we learned
- Structured output is a control plane. When each agent's JSON drives one piece of product logic, five agents stay predictable.
- An AI that refuses to do your work is the feature. The coach's refusal is one of its three response types, by design.
- Judging needs rules, not vibes. The judge passes only on observations specific to the deliverable, and fails only on a direct contradiction or missing proof at the final check.
Built during the hackathon
Submissions ran from June 16 to June 30, 2026. Before they opened, from June 12 to 14, the team wrote the PRD, TRD, and task list, a Live2D lip-sync spike, and the backend's skeleton, in 40 commits: models, the state machine, the scheduler, Sign in with Chutes, push, and email, with stubs in place of any AI. The hackathon's 219 commits built the rest: the Chutes client, the five agents and their prompts, the three companions, the evidence adapters, the frontend and its Live2D stage, and deployment. The 51 since then logged inference failures, made the chat backend switchable between Chutes and Gemini with KAWAN_AI_BACKEND, redesigned the landing page, and tidied the repo and its docs.
What's next
Known limitations
- Voice is built but not switched on in production, and speech input isn't wired in.
- Live updates arrive by Web Push and the timeline; the WebSocket isn't wired into the frontend yet.
- All guests share one account on the server.
- At the deadline, a screenshot or file commitment that wasn't finished early comes out "unclear", which counts as a miss. The state machine supports a 6-hour grace window that spends a skip day, but new commitments start with none.
- Check-ins are daily only, and the app is in English only.
- Nothing checks a TEE attestation at runtime; the catalog check is run by hand.
Roadmap
Monetary stakes, more cadences, voice in production, and live check-ins over the WebSocket. See open issues for a full list of proposed features (and known issues).
Getting started
Prerequisites
- git-lfs, for the Live2D models
- Python 3.12 with uv
- Bun
- A Chutes API key, and a Sign in with Chutes app for real sign-in
Installation
git clone https://github.com/M1KUAPP/Kawan.git
cd Kawan
git lfs pull
# backend, on port 8000
cd apps/backend
cp .env.example .env # set KAWAN_AI_BACKEND=chutes and KAWAN_CHUTES_API_KEY
uv sync
uv run uvicorn app.main:app --reload
# frontend, in another terminal
cd apps/frontend
bun install
bun run dev
bun run check at the root runs the linters, the tests, and the build. uv run python scripts/seed_demo.py --reset seeds demo data.
License
MIT. See LICENSE for more information.
Acknowledgments
- Chutes
- Live2D Cubism, and the Haru, Hiyori, and LiveroiD models
- Archify
- Shields.io
Built With
- apscheduler
- asyncpg
- bun
- chutes
- cubism
- fastapi
- github-api
- live2d
- pixi-live2d-display
- pixijs
- postgresql
- python
- react
- render
- sign-in-with-chutes
- sqlalchemy
- sqlite
- supabase
- tailwindcss
- tee
- telegram
- typescript
- vercel
- vite
- web-push