MYTHICALMIND

Nobody keeps a tidy task list — they keep context. The seminar starts at 08:00, registration needs a crew, the speaker lands at 10:00, lunch has to fit somewhere, and then the MC asks for a door-prize session two days before the event. A spreadsheet holds those rows fine, but it computes nothing: every clock in the time column is typed by hand, so shifting one duration silently invalidates everything below it. An AI chat fixes half the problem — it can draft a plausible flow — but the answer dies as prose. You cannot shorten one segment, reorder two others, assign a PIC, or hand the result to a committee as a printable document. Answering is not managing.

The idea compresses to one sentence: turn context into an executable rundown. MythicalMind is a workspace, not a chatbot. Thirteen curated templates (wedding, seminar, meeting, townhall, webinar, podcast, competition, school performance, retreat, productive day, exam study, mini event) give a fast start; the AI assistant drafts from a plain description; a spreadsheet-style editor polishes the result; PDF export produces the artifact a committee can actually hold. The principle that holds all of it together is review-before-persist: the AI proposes, the human decides. Nothing a model generated is written to the plan until a person has looked at it.

The “Susun dengan AI” wizard forces context in structured: name, type, category (event / daily / study / work), date, start time, target duration, goal, audience, notes. The system prompt is Indonesian with a rigid output contract — exactly one valid JSON object, segments sequential without overlap, totals chasing the target duration, PIC as a role. Streaming text from the provider is never trusted directly: an extractor strips code fences and prose wrappers, then zod validates the shape (1–40 segments, 1–600 minutes each). A malformed answer is rejected with a readable message — “some models drift from the format” — instead of poisoning the workspace.

This is the part that separates MythicalMind from a thin chat wrapper: generations belong to the server, not the browser. A GenerationManager singleton lives above any HTTP request and any React component. Navigate away — the stream keeps running; refresh the page — the SSE endpoint replays a snapshot plus live deltas; open six generations at once — they run in parallel, isolated, and anything beyond that queues. Each run carries its own AbortController, so the stop button kills exactly one generation and nothing else. Persistence is batched and throttled (750 ms, not one write per token), and on boot the manager recovers rows stuck in “streaming” so a restart never leaves orphans. The UI is only a subscriber.

What the model returns is a proposal, not a decree. The preview shows the title, a suggested start time, and every segment with its duration and PIC — each one adjustable in five-minute steps, deletable, or the whole result can be thrown back to the form via “Ubah input”. The provider and model used are printed above the result (“via Aurora Mock · aurora-pro” in this capture — the repo's own OpenAI-compatible test double), an honest attribution instead of a black box. Only “Simpan & buka editor” commits. That is an architectural decision, not decoration: state a human has not validated never touches the plan database.

The classic spreadsheet failure — clocks typed by hand — is solved by refusing to store clocks at all. Segment times are derived: rundown start time plus the cumulative durations above. Type a duration of 45, and start and end clocks compute themselves; reorder segments and the whole time column recalculates; drag nothing, align nothing. The editor is deliberately spreadsheet-like (commit-on-blur, arrow reordering, per-row detail drawers) because the people maintaining a rundown already speak in rows. The timeline strip at the top is a proportional visualization of the same derived data — a read, never a source of truth.

Reality edits the plan after the plan exists. The core session runs long, the committee adds a door prize, the closing needs a photo op. “Tambah dengan AI” opens extend mode: existing segments are sent as context and the model is asked only for what's missing — not a rewrite from zero. In this capture, the instruction “add a 15-minute door-prize session and a 10-minute closing parade” turned a seven-segment, 4h 10m rundown into nine segments totalling 4h 35m; every clock below the insertion shifted automatically, because times were never stored to begin with. Replanning is not generating a new answer — that is the whole difference.

MythicalMind refuses to lock you to one vendor. A universal OpenAI-compatible adapter takes any base URL and API key — OpenAI, Groq, OpenRouter, Together, LM Studio, vLLM, or a server on localhost — with automatic model discovery and per-message model switching. The adapter absorbs the quirks so the workspace doesn't have to: a native SSE parser, mapping for DeepSeek-style reasoning deltas, adaptive retry when a gateway rejects stream_options, and an error catalog that turns HTTP failures into readable Indonesian messages. API keys are never sent to the client — the UI only ever receives a masked hint like sk-…abcd. Every rundown, conversation, and provider record lives in one local SQLite file.

A rundown is finished when it can be printed and handed to a committee. Export runs client-side through jsPDF + AutoTable, dynamically imported so the editor bundle stays lean: a print-ready A4 document with a brand header, the event metadata, and a seven-column segment table (No, Waktu, Dur, Aktivitas, Detail, PIC, Catatan) carrying the same derived clocks, plus page footers with export date and page numbers. The palette flips to a light print-safe scheme with violet accents — paper, not screen. The capture below is the direct output of the running application, not a mockup.

As a local-first application, MythicalMind deliberately has no public URL — the data belongs to one machine. The architecture still runs anywhere Node runs: the standalone Next.js 16 build ships the server and assets in one folder, and the only environment it needs is a DATABASE_URL pointing at a SQLite file. That makes a laptop, a Cloud VPS, or AI-oriented hosting like AI Hosting equally valid homes — pick per privacy needs, not per vendor lock-in. Before the v1.0.0 release, a 17-step end-to-end acceptance script runs the real product through real HTTP against a mock provider that genuinely speaks the OpenAI protocol: connect, discover, stream across navigation, parallel generations, stop one of two active runs, refresh-and-resume, error mapping, adaptive retry.

Agentic UX is more than an LLM call behind a input box. Structured output is the line between a demo and a tool — one zod schema does more for reliability than any amount of prompt engineering. Derived state beats stored state: a timeline that cannot drift is built by deleting the thing that could. Server-owned generations rewrite the UX contract — the user is allowed to leave, and trust survives the refresh. Provider abstraction is empathy engineering: every quirk the adapter absorbs is a quirk the user never meets. And a mock provider that actually speaks the protocol finds the bugs that function mocks cannot — its fail-401, fail-503, and strict-400 models exist precisely so the retry and error-mapping paths are tested before a real key ever touches them.