let's start with a real example instead of a claim.
we built nudge as a full working system with el fin. later, a restaurant we work with needed something in the same shape — reminders that keep work moving — but not the same thing. they didn't need, for instance, the 24–48 hour stale-task reminders that mattered in the first build.
so we didn't rebuild from scratch, and we didn't force the old system onto them either. we took the modules that fit, dropped the ones that didn't, and shaped something that worked for a kitchen. that's only possible because nudge was built modular on purpose. a system built as one solid block can't be reused. a system built as parts can.
what "shared edge" actually means
this is the whole idea, and it's less magical than it sounds: something we figure out for one company becomes something we can apply at the next.
not by copying it whole — by reusing the parts that carry and rebuilding the parts that don't. every company we work with makes the toolkit a little deeper, and everyone connected to it gets that benefit. we all win from building this stuff once.
what the cohort builds, the cohort keeps.
think of it as a shared IT department
the clearest way to describe it: imagine a few companies sharing one IT department.
anyone who's watched a company grow has seen this — a full IT department gets built from nothing. it sets up the computers, runs the email, wires up the drives, fixes what breaks, and slowly works out which tools the business actually needs. one team, serving the whole operation.
now picture that same team, but shared across four companies instead of locked inside one. that's the backbone. and it isn't only workflows and automations — it's ai implementation, finding the right tools, building the ones that don't exist yet, and the basic infrastructure too: email setup, google drive, all the plumbing every company needs and nobody wants to build twice.
build it once, for everyone. learn it once, everywhere.
╭────────╮
│ CORE │
╰────────╯
│
╭─────────────┼─────────────╮
│ │ │
│ │ │
╭────────╮ ╭────────╮ ╭────────╮
│ CO A │░ │ CO B │░ │ CO C │░
╰────────╯░ ╰────────╯░ ╰────────╯░
░░░░░░░░░░ ░░░░░░░░░░ ░░░░░░░░░░the catch
the honest version: this only works when you build expecting to reuse. the restaurant got a fast, cheap system because the first one was designed to come apart. when we forget that and build something too specific, it stays stuck in the company it was made for. modularity is the cost you pay up front to be able to share later.
right now it's four companies on the backbone — enough to watch the pattern hold, early enough that we're still finding where it breaks.
the point
a shared core doesn't mean everyone gets the same generic tool. it means the opposite. because the foundation is built once and reused, we can afford to make what sits on top of it hyper-personalized — tools shaped to each company in the cohort, not one-size-fits-all software everyone has to bend to.
and the ai underneath has to earn its place. we don't reach for it because it's the trend, and we don't burn tokens to look impressive — we use it, focused, only where it genuinely makes a tool better. used with that discipline, the actual ai cost behind a system like this stays small. the leverage was never in spending more on models; it's in wiring them up well.
and what we build stays in-house. every system is owned infrastructure, not something licensed from a vendor who can change the terms tomorrow — so the value compounds where we can keep it.
the bet: a few companies sharing one sharp core can move faster than any of them alone — shared where it helps, personal where it counts. so far, it holds.