Flocci Infinity: The Whiteboard That Stopped Faking Its Coworkers

The best thinking your team did last quarter is gone. It happened at a whiteboard — the good kind of meeting, the one where someone grabbed a marker and the diagram kept getting redrawn until it was suddenly right, arrows and boxes and a circled thing in the corner that turned out to be the whole idea. Everybody nodded. Somebody said “let’s not lose this.” And then the meeting ended, the next team filed in, and a facilities marker wiped a quarter’s worth of clarity into a smear of ghost-ink. Maybe someone snapped a blurry photo. Nobody ever opened it. The thinking was real; the record was a whiteboard, and a whiteboard is a device for forgetting on a schedule.

The canvas has always lived in exile

Digital whiteboards were supposed to fix this, and they half did. The canvas became infinite and permanent — the smear was gone. But a new gap opened in its place, quieter and more expensive: the whiteboard moved into its own building. A separate app, a separate account, a separate login, a separate silo with no idea what it was a whiteboard about. The sprint plan you diagrammed had no thread back to the actual tasks. The architecture sketch didn’t know the doc that specced it. The roadmap you mapped in colored boxes couldn’t see the calendar it was supposed to fit inside. You’d draw the shape of the work in one universe and then re-type it into the universe where the work actually lived.

So the tool that promised to save your thinking mostly relocated the loss. Instead of ink evaporating off a wall, context evaporated across a login boundary. You still ended up with a beautiful board nobody connected to anything, admired once and abandoned in a workspace you had to remember to visit.

Flocci Infinity’s thesis is that the exile is the bug. Not the canvas — the canvas is great. The isolation of the canvas. So Infinity refuses to be its own building. It’s one room in a five-app work suite — projects, library, calendar, notes, and the whiteboard — all sharing a single Flocci account, a single backend, one realtime engine, and one AI. The board isn’t a place you go. It’s a surface inside the place you already are.

The tell: it used to draw its own coworkers

Here is the most honest and most revealing thing about Infinity, and it’s the kind of detail a brochure would bury. Its collaboration used to be fake. Early builds, to make the canvas feel alive and multiplayer, literally rendered simulated “ghost cursors” — phantom pointers drifting around to suggest teammates who weren’t there. It was set dressing. A whiteboard performing collaboration to an audience of one.

That’s not an embarrassment; it’s the whole story in miniature. Building genuine multiplayer — presence, live cursors, conflict-aware object sync — is hard, and a standalone whiteboard team would have had to build it from scratch, alongside its own auth, its own AI, its own everything. Infinity didn’t. On 2026-07-04, a single sprint on the shared backend swapped the ghosts for real socket.io presence. Live cursors that belong to actual humans. Object changes that broadcast and sync. And because the sync is done right, remote edits are kept out of your local undo history — so pressing undo rewinds your last move, not your colleague’s, and an X-Socket-Id echo suppresses your own changes bouncing back at you.

The part that pays off twice: that same sprint didn’t only fix cursors. Because Infinity draws its capabilities from a shared core, wiring real presence into the backend meant the whiteboard simultaneously gained Google SSO and DeepSeek-powered AI generation — features it never wrote a line to build. One backend swap; five apps lit up at once. Infinity is the clearest embodiment of the platform’s rule: fix it once at the core, and every domain inherits.

What the canvas is made of

Under the pretty surface is a real rendering engine, and the choice matters. Infinity draws on a true 2D canvas — not a pile of DOM nodes pretending to be shapes. Every object carries its own x/y/w/h, a rotation, a double-precision opacity, a z-index, and an opaque per-type data blob, persisted through a boards + canvas_objects domain model behind 14 JWT-guarded endpoints at /api/v1. That engineering decision is what makes the whole thing feel like a canvas rather than a webpage with draggable divs — and it’s also, concretely, what makes PNG export possible, because a real canvas can hand you a toDataURL.

Then there’s the creative layer, and this is where Infinity earns the word “whiteboard” instead of “diagram tool.” A command palette to summon anything without hunting through menus. A mindmap builder for the branch-and-node thinking a canvas is best at. A pen tool that runs your freehand strokes through a 1-euro smoothing filter, so the jittery line your mouse actually drew becomes the clean curve you meant. Connectors that auto-route between shapes instead of leaving you to nudge elbows by hand. All of it built on a React 18 + Zustand 5 + Framer Motion frontend — the two libraries, Zustand and Framer Motion, that are unique to Infinity among the suite’s otherwise-uniform five UIs, because a canvas that has to feel physical needs state and motion the calendar simply doesn’t.

1. Sign in once, land anywhere

   “Continue with Google” through the shared identity service. Register on any Work App and you’re already signed in to Infinity — the OAuth callback is mounted outside the AuthGate and auth calls carry credentials, so cross-app SSO just works.

2. Start from a template or a blank canvas

   Three seeded system templates — provisioned in both local Postgres and Neon — instantiate from a jsonb objects snapshot, so a board can open pre-populated instead of empty.

3. Draw, and let the AI draft

   Drop any of 13 object types, sketch with the smoothing pen, branch a mindmap — or ask infinity/generate to lay down a first-pass board for you to reshape.

4. Invite the team, watch them arrive live

   Share with owner/admin/editor/viewer roles; real cursors and presence appear as teammates join, object edits sync in real time, and your undo stays yours.

5. Present it, then export it

   Run Present mode to showcase the board, and export to PNG via the 2D canvas — the record that a physical whiteboard could never hand you.

One account, and the board stops being an island

Start from the coworkers. The canvas that used to draw phantom teammates to feel less alone now has real ones on it — and the only reason it does is that it stopped being an island. Those real cursors arrived through a shared backend, and the same shared backend is what ends the isolation the canvas was exiled into. You can see the seam in the AppSwitcher waffle, and the line printed under it: one Flocci account — every app. Infinity is one of five UIs served by a single Hono + Drizzle backend on port 5012, with its own dedicated database. Identity, socket.io realtime, and DeepSeek AI are wired once into that shared core and inherited by all five. Move from the calendar to the whiteboard to the wiki and there’s no second door, no re-login, no re-typing the plan you already drew. The board is finally about something, because it lives beside the tasks, docs, and meetings it was always trying to describe.

Be clear-eyed about the edges, because the product is. There’s no CRDT merge engine yet — collaboration is object and presence sync, not two cursors fusing a single paragraph. Export stops at PNG. And Infinity doesn’t yet emit events onto the platform Graph the way its siblings do. These aren’t hidden; they’re the honest shape of a whiteboard that got real, load-bearing collaboration only weeks ago and is building outward from a foundation that already works.

The thinking finally has somewhere to land

The whiteboard was always a device for forgetting on a schedule — brilliant for an hour, blank by the next meeting. Digital canvases fixed the smear and then reintroduced the loss one layer up, exiling your best diagrams to an app disconnected from the work they were about. Infinity’s answer isn’t a better marker. It’s to refuse the exile entirely: put the infinite canvas inside the workspace, one login from the tasks and docs and calendar, sharing the same realtime engine and the same AI as everything around it.

So the whiteboard that was a device for forgetting on a schedule finally does the opposite: it remembers. The diagram that used to die when the meeting ended now persists on a canvas that sits beside the tasks and docs it was drawing — and the coworkers it once faked are real people whose cursors move across it while you watch. The quarter’s best thinking no longer has to end up as a smear on a wall or a beautiful board no one connected to anything. When someone says “let’s not lose this,” the canvas is already keeping it, and the team that drew it is already there.