Flocci Calendar: The Dumbest Tool You Own Just Learned to Run the Meeting

Start with the one claim that makes Flocci Calendar worth the pixels: a calendar event should be the meeting itself — a live room you step into, with real audio, video, screen-share, chat, and minutes that write themselves the moment you’re done — not a dead reminder holding a video link somebody pasted in by hand. That sounds obvious until you notice no calendar you’ve ever used actually works that way. And it should, because the calendar is where the actual work happens. Not the doc, not the ticket, not the Slack thread — the calendar. It’s the grid your day is poured into, the place where meetings, standups, one-on-ones, and customer calls become real. It is the single most load-bearing app most teams own. And it is, almost universally, the dumbest one: a rectangle with a title, a time, and — if you’re lucky — that pasted-in link. It knows nothing about the conversation it schedules. It doesn’t host it, doesn’t record it, doesn’t remember a word of it. The most important sixty minutes of your week get organized by a tool with the intelligence of a sticky note.

The seam is where the work leaks out

Watch how a single meeting actually threads through your software. You schedule it in Google Calendar or Calendly. You paste a Zoom or Meet link into the invite. When the hour comes, you jump to the video tool. You chat about the agenda in a separate Slack channel. Someone half-listens while trying to take notes, or you bolt on Otter to transcribe, or — most often — nobody captures anything and the decisions evaporate the moment the call ends.

Four tools, minimum, to run one conversation. And the problem isn’t any single tool; each is fine at its job. The problem is the seams between them. Context lives in the calendar. The conversation lives in the video app. The side-chatter lives in Slack. The record, if it exists at all, lives in a fifth place nobody remembers to open. Decisions and action items fall through those gaps like coins through a torn pocket. You’ve all been in the meeting where someone asks “wait, what did we agree last time?” and the honest answer is: it’s gone. Not because nobody said it — because no single tool was holding the whole thing.

Flocci Calendar’s thesis is blunt: the fragmentation is the bug. The scheduling, the live meeting, the chat, and the minutes are not four products. They’re four views of one event. So it puts them on one event.

First, it is a real calendar

None of this matters if the calendar underneath is a toy, so it isn’t. Flocci Calendar gives you the four views you expect — month, week, day, and agenda — over events that are properly timezone-aware, color-coded by category, and carry recurrence, priority, and status. Each org is auto-provisioned five calendar categories the first time it loads, so a new team isn’t staring at a blank taxonomy. Attendees can be internal members or external guests: the event_attendees model allows a nullable userId keyed by email, which is the small, honest schema decision that lets you invite someone who doesn’t have a Flocci account and still track their RSVP.

Under the hood there’s a detail worth flagging, because it signals how seriously the team took reliability. The calendar core doesn’t lean on React Query like most of the suite; it runs on a custom EventBus persistence-and-connectivity engine with retry and backoff. Scheduling is the kind of thing that must survive a flaky connection — a dropped write on an event you’re about to attend is a small disaster — so the core is built to be offline-resilient by design rather than by hope. PATCH is the canonical update path (with PUT kept as a compatibility alias), and live changes stream to every open client over a calendar:events:changed channel. Move a meeting on your laptop and it’s already moved on your colleague’s screen.

Then the event opens into a room

This is the move that makes Flocci Calendar a different category of thing. Every event can spawn a Connect Cockpit — a communication room with a deterministic name (wa_{roomId}) and real media behind it. When the LiveKit environment variables are configured, the backend records the provider as livekit and mints a room-scoped join token, valid for two hours, at POST /api/rooms/:id/calls/token. GET /api/comms/config reports whether real media is available, so the client always knows which mode it’s in. When those keys aren’t present, it falls back gracefully to a mock-sfu mode with placeholder tiles — honest about the difference rather than faking a call.

Rooms carry roles — host, speaker, participant, viewer — plus recordings, so the huddle behaves like an actual meeting space and not a novelty video widget. And running alongside the media is the chat that used to live in a separate app entirely.

Chat that feels like the room, not a mailbox

The realtime layer is where you feel the difference in your fingertips. Flocci Calendar’s chat runs on socket.io channels — public, private, event-scoped, DMs, and group DMs — with threaded messages, emoji reactions, and delivery state. The change that tells the story is architectural: the old polling model, where a new message could lag by seconds, gave way to socket push that lands as you type. That’s not an incremental tune-up; it’s the gap between a chat that feels like refreshing email and one that feels like people are in the room with you. Polling still exists, but it’s been demoted to a disconnected-mode fallback — the thing that catches you when the socket drops, not the thing you live on.

There’s engineering discipline in the contract, too. New messages double-emit — once to the channel, once to the org — and clients deduplicate by id, so you get reliable delivery without seeing a message twice. Room state and transcript segments ride their own comms:* channels. The result is a conversation surface that’s stitched into the event, moving at conversational speed.

The minutes write themselves

Here is the payoff, and the reason to care. As the huddle runs, transcript segments accumulate in communication_transcripts — each one tagged with a speaker, a confidence score, millisecond offsets, and an isFinal flag. Those segments are the raw material. The model-backed path, POST /api/ai/transcript/analyze, sends them through Flocci’s shared intelligence service on DeepSeek and gets back not a wall of text but a structured meeting_artifacts record: an agenda, the decisions that were made, the action items that came out of it, the risks that surfaced, plus a summary and a sentiment read.

That distinction — structured artifacts, not a transcript dump — is the whole difference between “we recorded the meeting” and “we understand the meeting.” A transcript is a chore you now have to read. A decisions-and-action-items list is a thing you can actually use the next morning. And because the AI runs through the shared intelligence gateway with a Graph-ready envelope, a lighter in-room heuristic path exists too, so quick artifacts still appear even when the full model isn’t in the loop.

1. Schedule the event

   Drop it on the calendar — timezone-aware, categorized, with internal members and external email guests carrying their own RSVP. It syncs live to every attendee’s view.

2. Open the Cockpit

   When it’s time, the event becomes a room: real LiveKit audio, video, and screen-share with roles, plus the event-scoped chat running at push speed right beside it.

3. Talk; it listens

   Transcript segments stream in per speaker with confidence and timing. Nothing about the conversation is happening in a separate app you’ll forget to open.

4. Read the minutes it wrote

   On close, DeepSeek turns the transcript into agenda, decisions, action items, risks, summary, and sentiment — written back onto the same event, streamed over comms:artifacts:updated.

One app of five, one login for all

Flocci Calendar doesn’t stand alone, and the reason isn’t the usual suite-brochure one. Yes, it’s one of five work apps — with Projects, Library, Notes, and Infinity — served by a single Hono and Drizzle modular-monolith backend on port 5012, where Calendar owns its own Postgres database (DATABASE_URL_CALENDAR, local or Neon via the DB_TARGET flip), carrying three scheduling tables and fifteen communications ones. That’s a lot of surface area for something people mistake for a calendar. But the shared plumbing isn’t the interesting part. The interesting part is what it means when the app the rest of the suite connects to is the one where the meeting actually happens.

Because the meeting happens inside Calendar — not in some external tab it merely links to — its output has somewhere to go. You sign in once through the shared identity service with “Continue with Google,” and an AppSwitcher waffle jumps you between all five apps, with Calendar as the blue tile. A task in Projects already syncs into the calendar as an event with a linked badge, through a typed cross-links table that understands notes, pages, issues, events, and boards — so a decision reached in a huddle doesn’t die on the event; it has a path outward. And every event publishes to the shared Graph event outbox, which means the place your meetings live is also a source the rest of the platform can act on.

The vision, and where it honestly stands

There’s a version of this idea that’s pure vaporware — a mockup where the video is a screenshot and the AI notes are lorem ipsum. Flocci Calendar is deliberately not that. The media is real LiveKit when configured, gated behind actual environment keys and room-scoped tokens. The realtime layer is real socket-push, not a promise — chat and event changes propagate as they happen instead of on a polling timer. The AI path runs through a real shared service on a real model. What’s early is early in the honest sense: per-user billing and metering on the AI calls, deeper cross-app links, the full breadth of the Graph. Those are foundations being poured, not gaps being painted over.

But the core argument is already whole. For most teams the calendar has only ever been the place work gets announced — a grid of titles and times pointing at conversations that happen, and evaporate, somewhere else. Flocci Calendar’s answer is to stop treating the event as a reminder and start treating it as the container for the entire meeting: the room you talk in, the chat you talk beside, and the minutes that write themselves when you’re done. When the event is the meeting, the calendar stops being the place work is announced and becomes the place work actually happens — the room, the record, and the decisions all living on the same rectangle you were going to open anyway. The dumbest tool you own just learned to run the meeting, and that was always where the meeting belonged.