Hi. I’m Maxim. I’ve been doing Android for about five years, and I kept hitting the same wall: I wanted to roll out features gradually, kill something in one click when it goes wrong, and not bet the whole release on a single big deploy. So basically — feature flags and a sane way to run experiments. But everything I tried felt off.

Sometimes the stack didn’t match: no real Kotlin-native story, everything through wrappers. Sometimes it was a full-blown platform with tons of features when I just needed "on/off" and simple A/B. Or yet another cloud service — their pipeline, their limits, their contracts. So I thought: fine, I’ll build what I’d actually use. That’s how Flagent started.

What I was actually missing

A few things. First, feature flags themselves: turn features on and off without pushing a new build to the store. Not "commit and wait a week" but "flip in the admin — app behaviour changes." Second, experiments: not random if (BuildConfig.DEBUG) scattered in code and not "let the backend figure it out," but clear rules — who sees what, what percentage, which variant. Third — all of that had to work with Kotlin and the stack I already use, not a whole separate world with its own SDKs and quirks.

I looked at what's out there — existing products and homegrown setups at various companies. Took ideas from several, but never found one "this is it." So I started a side project and built it for myself.

What's in Flagent right now

It's an open-source backend plus a small admin UI. You self-host it and plug your apps in via API or SDK.

The backend is Ktor, clean architecture inside, no bloat. DB: PostgreSQL, MySQL, or SQLite (SQLite is handy for local tinkering). The admin UI is Compose for Web: you create flags, set up segments (who falls into which bucket), variants, constraints. There's a debug console so you can see why a user got or didn't get a variant.

SDKs exist for Kotlin (including an "enhanced" one with offline evaluation and live updates over SSE), JavaScript/TypeScript, Swift, Python, Go. Plus a Ktor plugin for server-side evaluation. Flag evaluation is deterministic: same user, same rules — same variant every time (MurmurHash3). No "in A today, B tomorrow." You can target by segments and constraints: region, subscription tier, whatever you pass in context.

For mobile, the important bit is client-side evaluation in Kotlin (and Go): after one snapshot fetch, flags are evaluated locally — no server round-trip on every isEnabled(). And real-time updates over SSE: change a flag in the admin, clients pick it up in seconds without restarting the app.

So you can already run the server, create flags, wire up your app, and either gate features behind flags or run simple A/B tests. I didn't reinvent the wheel — I looked at how other platforms do it — but I put it together the way I like: type safety, coroutines, self-host, no vendor lock-in.

How to try it

Fastest way is Docker. You need to pass admin credentials and a JWT secret or you won't get into the UI (we fixed that in the docs recently). Minimal run:

docker run -d -p 18000:18000 \
  -e FLAGENT_ADMIN_EMAIL=admin@local \
  -e FLAGENT_ADMIN_PASSWORD=admin \
  -e FLAGENT_JWT_AUTH_SECRET=any-secret-at-least-32-chars \
  -v flagent-data:/data \
  ghcr.io/maxluxs/flagent

Then open http://localhost:18000, log in (admin@local / admin), create a flag, grab the API key from the tenant settings. In your app you add the SDK and check:

if (client.isEnabled("my-feature")) {
    // new behaviour
} else {
    // old one
}

Full walkthrough is in Quick Start and the docs — how to set up the DB, deploy, which env vars you need, how to plug in the SDK for your language.

Where it’s going

Right now it’s a side project. I’m building it for my own use first, but I’d like it to be something others can rely on too: solid docs, straightforward self-hosting, maybe a managed option later. I’m not nailing down a roadmap — I’m just sharing what’s there and where I’d like to take it.

If this resonates — you’re on Kotlin or Ktor, or you just want a simple self-hosted flag server without a cloud subscription — I’d be glad if you gave it a try, starred the repo, or dropped a note in an issue or discussion about how you’d use it. That feedback is what’ll drive the next steps.

Thanks for reading. Repo is on GitHub, everything else is in the docs.