Flocci Bento: The Link-in-Bio That Refuses to Flatten You

You get one link. It goes in the bio, under the talk, at the bottom of the cold email — and it has to be the whole of you. Not a slice. The whole thing: the work, the numbers, the thing you shipped last spring, the way you actually think. And what does the internet hand you to carry all that weight? A vertical stack of identical pill-shaped buttons. Name, avatar, seven rounded rectangles in a column, a wash of gradient behind them. Every “link page” on earth is the same page wearing a different color. The medium that was supposed to represent you flattens you into a list.

The tyranny of the stack

The link-in-bio genre made a quiet bargain, and most people never noticed they’d signed it. In exchange for setup that takes ninety seconds, you agreed to look exactly like everyone else. The tools optimize for that. They give you buttons because buttons are safe, uniform, and impossible to get wrong — which is also why they’re impossible to make yours.

But a person, or a product, or a portfolio, is not a stack. It has proportion. Some things are big and some things are small, and the arrangement of big and small is where meaning lives. A hero project deserves more real estate than a contact link. A chart that took you three years to earn should not be the same size as your Twitter handle. This is the whole idea behind the bento grid — the Japanese lunchbox logic that took over interface design because it’s simply how humans read importance: by area, by adjacency, by rhythm.

The problem is that building a real bento grid in a general-purpose design tool is a small war. You’re bolting rectangles onto an infinite canvas that has no idea what a grid is. There are no charts on hand, no device mockups, no clean way to let a machine help you without it producing a separate file you then have to reconcile. You spend your afternoon fighting the tool instead of composing the thing. The friction isn’t the design. The friction is the software.

Grid-native, not shapes-bolted-on

Bento’s editor — the aptly named BentoEditor — is built on react-grid-layout, which means the grid is the substrate, not an afterthought you impose on a blank rectangle. Panels snap, resize, and reflow because the canvas natively understands rows and columns. That single architectural choice is what separates “a design tool you can make a grid in” from “a grid you compose in.”

And the panels aren’t dumb boxes. Each one can hold a genuine content type, ready to go, no plugin hunt required.

That asset pipeline deserves a line of its own. Bento accepts uploads, inline base64, and even external URLs through a proxy; it generates thumbnails with sharp; and it runs sha256 deduplication so the same image dropped into ten projects is stored exactly once per owner. This is plumbing you’re never supposed to notice — which is precisely the point.

The AI edits your document

Here is where Bento does something most tools only pretend to. Almost every product with an “AI assistant” bolts it on the side: you ask, it thinks, and it hands you back a separate draft that you then have to reconcile with the thing you were actually working on. Two documents, one of them stale, and a merge you do by hand.

Bento refuses that. Its AI features — text rewrite, layout suggestion, copy-fill, and async image generation — don’t produce a rival draft. The layout and copy endpoints return their changes as JSON-Patch operations, in the exact same wire format that your own human edits travel in. Your click, your undo, and the AI’s suggestion all flow through one identical mutation pipeline. The AI isn’t a consultant handing you a memo. It’s a co-editor with its hands on the same document.

And it’s free. Not free-with-an-asterisk — the AI is routed through the shared Flocci intelligence service with charge: false, meaning no credit accounting happens at all. The app owns no AI keys and no Google client of its own; it reaches DeepSeek through the platform gateway. You get an editing collaborator without a meter running in the corner.

Start as a guest, commit when you’re ready

The other friction Bento removes is the one that kills more projects than any design problem: the signup wall. You shouldn’t have to prove your identity to a tool before it has proven anything to you.

1. Just start building

   Open the canvas and compose. No account, no email, nothing. Your work persists in the browser’s localStorage as you go, so a refresh won’t cost you.

2. Decide the tool is worth it

   Get the layout to a place you’re proud of — on your own time, with zero commitment asked of you up front.

3. Sign up, and your work comes with you

   On signup, an idempotent POST /v1/migrate/local carries your guest state into the cloud. Because it’s idempotent (scoped through an IdempotencyKey), it can’t duplicate your project no matter how the network behaves.

4. Now you get the cloud powers

   Members with owner/editor/viewer roles, tokenized public share links for view, comment or edit, and full version history — up to 100 snapshots and 20 named drafts per project, with persistent undo/redo on top.

That migration detail — idempotent — is the kind of thing you only appreciate after a tool has once eaten your work on a flaky connection. Bento was built by people who clearly have that scar.

The friendly canvas hides a security product

Now for the part worth slowing down on. Flocci Bento presents as a cheerful little drag-and-drop grid maker. Under the hood, it is quietly one of the most platform-hardened codebases in the Flocci estate.

The auth is not a basic access-token-plus-refresh pair. It’s family-based refresh-token rotation with reuse detection: refresh tokens are 48 random bytes, stored only as sha256 hashes, and rotated on every use. If a token that has already been rotated gets replayed, Bento treats it as a break-in and mass-revokes the entire token family — attacker and legitimate user alike get torched, because the safe assumption is that the session is compromised. Password storage itself is delegated to the shared Flocci identity service: the app keeps no password hashes of its own, verifying a legacy hash only long enough to migrate an old local account across. This is the posture of a banking session, wearing the skin of a v0.1 design toy.

The discipline continues into the schema. Bento already models AuditEvent, TelemetryEvent, Webhook and IdempotencyKey tables at v0.1 — a recordAuditEvent() call fires on nearly every mutating route. In the KB it’s described as the most Graph-ready schema in the estate, which means when the Flocci Graph outbox arrives, adoption for Bento is connect, not build. Sixteen Prisma models, sixty-three registered /v1 endpoints, a Fastify 5 backend and a React/Vite front end. That is not the anatomy of a weekend hack.

Bento rides the Flocci estate

Bento doesn’t stand alone, and that’s the point. It authenticates through the shared Flocci identity service, so one Flocci login and Google OAuth work across every app in the estate — with legacy accounts lazy-migrating to the shared identity on first sign-in. It reaches AI through the intelligence service via a single gateway client. It targets the notification service for its (currently stubbed) password-reset and invite emails. It stays resolutely free — no PayU, no credit accounting, charge: false on every AI call. It runs on registry port 5010 against a local flocci_app_bento database and deploys on Vercel against the public gateway.

In other words, Bento takes the boring-but-hard problems — identity, security, AI routing, audit — and inherits them from the platform instead of reinventing them. What’s left for the product to be about is the only thing that should be: the canvas.

The whole of you, at full resolution

The link page was never a bad idea. It was a good idea that got compressed until it lost its shape. One link should be able to carry the whole of you — but only if the medium has room for proportion, for the big thing next to the small thing, for a chart that gets to be a chart and a headline that gets to breathe.

Flocci Bento gives that medium a grid-native canvas, a co-editing AI that speaks your document’s language, a guest-first door with no wall, and a backend built with the paranoia of a security team. Some of it is still arriving — the high-DPI export is a promise, the invite emails a stub — and the roadmap says so plainly. But look past the cheerful drag-and-drop surface, and the real shape of the thing comes through: this friendly little design toy is quietly serious infrastructure. Banking-grade session security, an audit trail on nearly every mutation, the most Graph-ready schema in the estate — all of it inherited from the platform and hidden under a canvas that just wants to help you look like yourself. That is not a link-page gadget. It is the way you show up on the internet, built to outlast the version number on the door. One canvas. Full resolution. The whole of you.