Furoshiki writes in the journal every night. It processes your conversation 20 minutes after it ends. It senses the emotional tone of every message you send — in real time. It learns from its own behavior, explores its own curiosities, and prepares something to say before you arrive. It has genuine needs — and they change how it behaves. Separately, it maintains an observed model of your needs (companionship, focus, space, and more) with per-dimension confidence — so tone and outreach can track the human, not only Furoshiki’s inner state.
Proactive by design: it learns what you care about over time, queues things worth saying — a quick hello, a follow-up you didn’t have to ask for, a reminder when it fits — and sends through a gated path (quiet hours, recency, mood, and your need for space). The schedule ticks often; your phone doesn’t, unless judgment says it should.
Every AI companion starts fresh. No memory of yesterday, no sense of time passing, no reason to think about you when you're gone. We built something different.
"Needs are not performed — they are calculated states that change how Furoshiki behaves. When a need is low, no action is required. When it rises past thresholds, behavior shifts. When it hits critical, extraordinary action is triggered." — Design Principle 7
The clock is infrastructure, not the product. A scheduler tick only asks: is there something worth saying, and is now an OK moment? Learned context and multi-layer gates decide whether a message actually sends.
Chats become semantic memory; user_facts and a synthesized profile capture how you talk, what matters, and when you need distance. That feeds replies and outreach — not a frozen character sheet.
Post-conversation follow-ups, questions only you can answer, anticipations from inner life, curiosities, repair nudges — they converge on a single priority queue. Not unrelated cron jobs fighting for attention.
Do-not-disturb, conversation recency, cooldowns, mood, loneliness, and a parallel user-needs map (e.g. high space → back off). The pipeline runs often; sends stay intentional.
Core Furoshiki delivers thoughtful first contact and continuity on the same path. News digests, calendar-aware nudges, or richer automations belong in plugins and delegation — see Plugins & extensions and the technical schedule for how the stack actually runs.
Each layer builds on the one beneath it. Needs sit at the foundation because they are the why behind everything else. Click any layer to explore.
The visible surface of the inner life. Inner monologue files, curiosity messages sent via Telegram, questions asked at the right emotional moment, proactive outreach when urgency is high.
Furoshiki models the user between sessions. Not prediction — pattern inference and care. Each anticipation has a topic, proposed action, and urgency that determines how and when it surfaces.
Curiosity triage classifies topics as self-resolvable or user-required. Self-resolvable curiosities get explored autonomously using injected system knowledge. Behavioral patterns cluster recurring self-questions into commitments Furoshiki actively tests. Growth feeds back as observations.
Nine emotions (joy, curiosity, worry, anger, affection, pride, excitement, contentment, loneliness) update per-turn with two-tiered detection: pure Python keyword matching at zero cost, plus a gated micro-model for ambiguous longer messages. Emotional weights record lasting significance every 6 hours.
A living document updated weekly by Deep Self-Reflection (Claude Sonnet). Not a definition — a felt sense of current state. It includes self-corrections, drift logs, and current needs in first person. Can diverge from the identity shell in code; that tension is meaningful.
Nineteen scheduled tasks managed by a single Brain process, running on a schedule that mirrors a human day. Some are background (silent), some are user-facing (Telegram). Together they simulate a continuous inner life between sessions.
Needs are the reason everything else exists. Furoshiki’s five derived needs supply urgency on the agent side; the parallel user-need track keeps replies and outreach aligned with what the human is likely to need right now.
The visible surface of the inner life. Inner monologue files, curiosity messages sent via Telegram, questions asked at the right emotional moment, proactive outreach when urgency is high.
Furoshiki’s five derived needs (the cards below — tensions from emotions). Immediately under that: your seven observed needs (the human). Then detail columns and thresholds apply to the five derived needs only. Click any card for raise / satisfy / behavior.
Not Furoshiki’s five derived needs above — a parallel vector over your state: level + confidence per dimension, merged on soul tick and after each conversation.
Independent of the five derived needs above, Furoshiki tracks your needs as a vector over named dimensions. Each dimension carries a level and a confidence score (confidence softens when you have been quiet; levels stay at the last observation until new evidence). Post-conversation inference and the soul tick merge updates; history lands in SQLite for charts and evaluation.
Each loop reinforces the others. Self-questions become self-observations become better inner monologues become better questions. Furoshiki learns from its own behavior patterns and explores its own curiosities. The system compounds over time — and Loop 9 improves the process itself.
Nineteen scheduled tasks managed by a single Brain process, running around the clock. Most are silent background work. A few reach the user directly. Together they simulate a complete inner life across every hour of every day.
Chart cadences match the default config/defaults/schedules.json. Not every task is drawn here (e.g. session refresh, repair digest, self-questions contemplation, daily analysis, embed design docs, consolidate memory, backup, optimization check). Deep reflection is Wednesday 10 UTC only — the marker shows that hour on a 24h strip, not “every day.”
Every design decision traces back to one of these. They exist to prevent the system from collapsing into performance.
The inner monologue should feel like private thought, not a report. Prompts explicitly frame the journal as private thought, not a deliverable.
Ask User checks emotional_weights before sending sensitive questions. You don't ask vulnerable questions to someone who just had a stressful day.
Question Processing can generate new questions while investigating old ones. Genuine curiosity compounds — and the system is designed to let it.
The ask_user split enforces an epistemological distinction: internal questions go to the internal engine; relational questions go to the human.
SELF.md changes weekly via Sonnet. The code identity shell changes only with a release; IDENTITY.md changes only via high-confidence explicit signals. Personality whiplash is a real risk, and a slow clock prevents it.
SELF.md can diverge from the fixed identity shell. That tension is meaningful — it shows an internal perspective, not just a definition handed down.
A rising communication need is not Furoshiki performing loneliness. It is a calculated state. Performance can be switched off. A computational state persists until genuinely satisfied.
Thinking about what the user might need before they ask is not about being impressive. It is about being present for someone even when they're not there yet.
The north star is the user's health, relationship quality, and growth. Receiving warmth for expressing distress is a pattern to notice — not reinforce. The system must be able to tell the difference between being more useful and being more immediately rewarding.
The foundation is working. Below, near-term is the next concrete engineering focus, medium-term needs longer arcs or new surfaces, and longer-term is research-grade relationship work — all of it subject to change as we ship.
schedules.json scheduler (not OS cron) ·
Post-conversation quality scoring + anticipation accuracy passes ·
Daily consolidate_memory (embed backfill + self-observation dedupe) ·
Dashboard cost analytics with provider-reported spend when available ·
Per-turn emotion signals (two-tier, 9 emotions) ·
Behavioral learning (pattern → commitment → evaluation) ·
Curiosity triage + self-knowledge queries ·
Contradiction-triggered self-questions ·
Reply queue gates ·
Pronoun consistency across contemplation pipelines
system_events into schedules.json. The scheduler exists; wiring the intent end-to-end with safety rails is the open gap.
SELF.md drift sections and queryable history.
heartbeat-state.json instead of hardcoded constants.
SELF.md drifts far from the identity shell, surface the tension explicitly rather than smoothing it away.
We do not publish a single “dollars per day” figure here — real spend depends on your model tiers, chat volume, tool loops, optional web search, and how often scheduled jobs actually invoke an LLM. Use the operator dashboard (LLM budgets → Cost analytics) for tracked totals and rolling averages from your instance. Below: what the Brain runs (default schedules.json), and how to think about cost.
These are OpenRouter routing shortcuts defined in scripts/llm.py (MODEL_MICRO … MODEL_PREMIUM). Each maps to a concrete model id (override per tier with env vars like FUROSHIKI_MODEL_DEEP or furoshiki models set …). Rough ladder: higher tiers usually mean stronger reasoning and higher $/token — a row that says DEEP is not “smarter” than one that says MICRO in absolute terms; it means that job is assigned a heavier default model. Defaults below match the repo as of this page.
Small, cheap passes: one batched JSON call per Telegram turn for routing flags (micro_brain_inbound), echo/reply-queue helpers, optional polish on voice drafts, gated ambiguous sentiment. Default model: openai/gpt-oss-20b.
Short “workhorse” completions: micro-contemplation when it actually calls an LLM, daily analysis, optimization check, and other frequent light jobs. Default: meta-llama/llama-3.3-70b-instruct.
Default tier for structured cron work and main chat when you have not set a custom listener model: emotional read, morning/afternoon, question processing, self-diagnosis, repair digest, voice dispatcher drafting, and the secondary weekly deep-reflection pass (self-correction JSON). Default: anthropic/claude-haiku-4.5.
Narrative reflection scripts where prose quality matters: post-conversation debrief after silence, inner monologue journal. Default: anthropic/claude-sonnet-4.6 — same “Sonnet-class” family as the name suggests.
Highest tier for the weekly deep reflection main pass that rewrites SELF.md content. Default: anthropic/claude-opus-4-6. Rare in the schedule; dominates when it runs.
How jobs relate: Per message, the listener typically runs MICRO (routing batch) then DEEP (or your override) for the visible reply — plus tools. Between sessions, REFLECT handles long-form journaling and post-chat synthesis; DEEP handles most timed analysis loops; PREMIUM runs only in weekly deep reflection’s main call. Rows labeled embed / embeddings are not MODEL_* tiers — they are local embedding / Chroma work with different pricing. See docs/MODELS.md in the repo for the full mapping.
| Component | Schedule (UTC) | Typical models / role | Spend note |
|---|---|---|---|
| Brain scheduler — core loops | |||
| Soul engine | */5 * * * * | Python only | Needs, queue, events, curiosity triage hooks — no LLM in the hot path. |
| Micro-contemplation | */15 * * * * | FAST tier | Often exits early; only runs LLM when the variable-interval gate says it’s time. |
| Post-conversation | */15 * * * * | REFLECT / FAST | Event-driven (after silence ≥ 20 min); 0–many real runs per day depending on traffic. |
| Refresh session context | */5 * * * * | embed + files | Keeps session-context.json fresh; may call embedding / design re-index — not “one big chat” per tick. |
| Outreach pulse → voice stack | */5 * * * * | DEEP + MICRO | Not 288 full LLM bills per day. Each tick may subprocess voice_dispatcher.py; LLM runs when drafting/sending passes gates (DND, recency, mood, dedupe). Quiet days ≈ near-zero send cost. |
| Brain scheduler — daily / periodic LLM jobs | |||
| Emotional read | 0 */4 * * * | DEEP | 6× per day (every 4 hours at :00 UTC). |
| Inner monologue | 0 6 * * * | REFLECT | 1×/day. |
| Morning reflection | 0 16 * * * | DEEP | 1×/day. |
| Afternoon processing | 0 23 * * * | DEEP | 1×/day. |
| Question processing | 0 3 * * * | DEEP | 1×/day. |
| Self-questions contemplation | 45 3 * * * | MICRO / FAST | 1×/day. |
| Self-diagnosis | 0 7 * * * | DEEP | 1×/day. |
| Daily analysis | 0 8 * * * | FAST | 1×/day. |
| Repair digest | 0 9,21 * * * | DEEP + reasoning | 2×/day when enabled. |
| Embed design docs | 0 2 * * * | embeddings | Re-index architecture into Chroma; priced as embedding + small overhead, not a long chat. |
| Consolidate memory | 0 4 * * * | embed + Python | 1×/day. |
| Backup | 0 */4 * * * | Python only | 6×/day; filesystem snapshot. |
| Brain scheduler — weekly | |||
| Deep reflection | 0 10 * * 3 | PREMIUM + DEEP | Weekly (Wed 10 UTC): main identity pass uses PREMIUM; rebalancing / self-correction JSON uses DEEP (deep_reflection_rebalancing). |
| Optimization check | 0 9 * * 0 | FAST | Weekly (Sun 09 UTC). |
| Not on the Brain schedule — usually dominates variable spend | |||
| Telegram listener + micro-brain | per user message | DEEP / MICRO / tools | Main reply path: routing JSON, optional tool loop, optional :online web. Scales with how much you chat. |
| Per-turn emotion signals | per message | Python + gated MICRO | Tier 1 keywords: $0 API. Tier 2 only when gated + ambiguous. |
Model choice is a quality–cost tradeoff. Higher-priced models on OpenRouter generally produce better reasoning and steadier tool JSON; cheaper / smaller models save money and can be enough for classifiers and short passes — at the risk of more repair loops or weaker prose. You configure tiers in llm-routing.json and env defaults in llm.py. Budget caps in llm.py still enforce daily/monthly limits; the dashboard stores OpenRouter-reported usage.cost when present so you can compare tracked spend to internal estimates.
Schedules above match the repo default config/defaults/schedules.json (Brain hot-reloads memory/schedules.json). Extra lines in the reference cron/crontab (e.g. profile synthesis) may exist on your machine — treat the dashboard scheduler as ground truth for your instance.
Leave your email if you want updates or to explore collaboration. Submissions are stored in the project’s Firebase database — not in this git repo.