Skip to content

Release gradually, switch off instantly

Feature Management · Feature flags and experimentation

Typed flags on the OpenFeature model, with segments, percentage rollouts and a kill switch. A/B experiments with significance analysis, including on data in your own database. A release monitor and cleanup of stale flags. And runtime configuration with JSON Schema, reviewed changes, scheduling and one-click rollback, read by a JS/TS SDK that evaluates locally.

The problem

What this product solves

Without flags, every visible change goes to everyone at once, and rolling back means a new deploy.

Homegrown flags tend to become forgotten configuration, with no type, no owner and no history of who changed what.

Parameters that change production behavior, such as an assistant's model and prompt, end up in environment variables, outside any review.

updated

Who uses it, and for what

Typical profiles, no customer names. Each use carries the status of the feature behind it.

  • Product team at a retail appRelease a new screen to a small group before opening it to everyone, and switch it off instantly if something goes wrong.Feature flags
  • Product teamCompare two versions of a checkout flow with statistical analysis, without calling a winner on gut feeling.Experimentation
  • Team running an AI assistantChange model, temperature and prompt per environment with a second person's approval and no new deploy.Runtime configuration

Features

What the product does

Self-service: add it from your account.

  • Feature flags

    Typed flags, segments and kill switch compatible with OpenFeature.

  • Experimentation

    A/B tests with significance analysis.

  • Runtime configuration

    Configs and AI Configs on the flags engine: validated JSON Schema, versions, targeting, reviewed changes with approval, scheduling, one-click rollback and a JS/TS SDK with local evaluation.

  • Warehouse experiments

    Experiment analysis on your own database: a read-only query through the data connector (validated SELECT, allowed tables, audited without the data) and the same statistics as experiments.

  • Release monitor and flag cleanup

    After each flag change, compares the burn rate of the service SLOs in the hour before and the hour after and suggests the kill switch when it got worse; lists flags that serve a single variant (screen, API v1 and the flag_cleanup MCP resource) and opens, for each one, a Code Automation ticket that removes the flag from the code with an approved plan and review by someone else.

How it works

From start to audit record

  1. Flag

    You create a typed flag with its variants. Your code queries it through the SDK or an OpenFeature provider, always with a default value.

  2. Audience

    Rules by context attribute, segments and percentage rollouts, per environment. The same context always lands on the same variant.

  3. Reviewed change

    In a protected environment, publishing becomes a request with a note and a diff, approved by someone else, applied immediately or on a scheduled date.

  4. Measurement

    The experiment records exposures and metric events and compares each variant with the control, using significance analysis.

  5. Rollback

    The kill switch turns the flag off without publishing anything. One-click rollback returns to the previous version, with a note and a record. The release monitor suggests switching off when the service SLOs degrade after the change.

  6. Cleanup

    Flags serving a single variant show up as candidates, and each one can become a Code Automation ticket that removes it from the code, with review.

Features

Feature by feature

What each one does, how it works, an example from the documentation and what it does not do. Each badge comes from the catalog.

Feature flags

Code ships turned off and opens by audience, with instant rollback.

Typed Feature flags (boolean, string, number and JSON) with variants, per-environment audience rules, reusable segments and percentage rollout. Each evaluation returns the value, the variant, the reason and the metadata, following the OpenFeature model, so your code talks to an open standard rather than a proprietary API.

Evaluation order is fixed and predictable: kill switch, flag off, rules in the order they were written and, finally, the default rule. The kill switch is an environment state, not a version state: it turns the feature off immediately, without publishing anything and without a new deploy.

How it works

  • Rules with conditions on context attributes (equals, not equals, in list, greater and less than, starts with, ends with, contains and semver comparison) and up to 5 segments per rule.
  • Segments with conditions and lists of included and excluded keys, shared across the workspace flags.
  • Percentage rollout with stable distribution: the bucket comes from the SHA-256 of the flag key, the salt and the context key, across 10,000 buckets. The same context always lands on the same variant.
  • OpenFeature providers for server and browser in the JS/TS SDK, which evaluates locally from a snapshot with the same engine the server uses.
  • One SDK key per environment, shown only once; generating a new one revokes the previous one. Every call also carries an API credential with the flags:evaluate scope.
  • Per-environment flag state readable through API v1 and the MCP server. Each published version is immutable and records who published it; rolling back is a new publication.
With OpenFeature The AIUBY provider plugs into the server OpenFeature client; the lookup takes the default value and the context. Outside the monorepo, the same client is the @aiuby-ia/flags package on npm.
import { OpenFeature } from '@openfeature/server-sdk'
import { AiubyFlagsServerProvider, createFlagsClient } from '@aiuby-ia/flags'

await OpenFeature.setProviderAndWait(new AiubyFlagsServerProvider(createFlagsClient({ credential, sdkKey })))
const value = await OpenFeature.getClient().getBooleanValue('checkout-novo', false, { targetingKey: 'cliente-42', plan: 'pro' })

What it does not do

  • Rules do not accept regular expressions: use starts with, ends with or contains.
  • Changes are not pushed over SSE: they reach the SDK through polling with ETag (5 s minimum, 30 s default).
  • The official SDK is JS/TS, for the browser and Node 18+. Other languages use the remote evaluation route.
  • The credential does not go to the browser: the snapshot includes the segment key lists, so the front end receives it through a route on your backend.

Experimentation

Choose between variants with statistics, not gut feeling.

An experiment is a flag with rollout across variants plus two measures: exposure (who saw which variant) and metric events (what each context did afterward). The report compares each variant with the control and only declares a difference when it is statistically significant.

For conversion, the report uses the two-proportion z-test, with a Wilson interval per variant and a Wald interval for the difference; for means, Welch's test. With more than one variant against the control, the Bonferroni correction applies, with α = 0.05.

How it works

  • Exposure is only accepted with the signed token that server evaluation returns, valid for 24 h. Nobody can record exposure to a variant they did not receive.
  • Metric events with name, value and context key. Admins define the accepted value range per metric.
  • A pseudonym instead of the identity: the database stores only an HMAC of the context key, derived from the server secret and the environment salt. Someone reading the database cannot recompute the hash of an email.
  • Small sample warning: with fewer than 30 contexts per variant, or fewer than 5 successes or failures in a conversion, the report declares no variant significant.
  • Without significance after correction, the report names no winner.
  • Exposures and metric events are kept for 90 days.
Through the SDK API Evaluate on the server, record the exposure with the returned token, send the metric events and read the report.
POST /api/platform/flags/sdk/evaluate   { context: { key, ... }, flagKey }
POST /api/platform/flags/exposures      { exposures: [{ token, occurredAt? }] }   token = flagMetadata.exposureToken
POST /api/platform/flags/metrics        { events: [{ name, value = 1, contextKey, occurredAt? }] }
GET  /api/platform/flags/experiments/{flag}/report

What it does not do

  • The report only considers exposures and metric events sent to the platform; to measure with data from your own database, warehouse analysis uses the same statistics.
  • Local SDK evaluation does not generate the exposure token; experiments with recorded exposure use remote evaluation.
  • The report is for workspace admins only, and the order between exposure and event is the order the server received them.
  • Rotating the server secret changes the pseudonyms: running experiments start over from zero.

Runtime configuration

Change application behavior without a deploy, with review.

A runtime configuration is a JSON flag with a JSON Schema: the same engine as feature flags, with immutable versions, audience rules by environment and segment, a kill switch and SDK keys. Every variant of every version is validated against the schema before it is saved, so a malformed value never reaches the application.

The AI Config preset ships a ready-made schema for AI parameters (model, temperature, topP, output token limit, prompt from the workspace library, stop sequences and limits). Your application reads the configuration through the SDK and applies it; AIUBY does not call a model with it.

How it works

  • Protected environment: direct publishing returns 409, and the change becomes a request with a required note, pending until another admin approves it. Authors cannot approve their own request; the database refuses it as well.
  • Review diff between the current version and the requested version, before the decision.
  • Scheduling up to 90 days ahead: the approved request is applied on the date, on behalf of whoever authorized it last. If the current version changed since the request, it fails instead of applying a stale diff.
  • One-click rollback to the version that was live before the current one, immediately, with a note and an audit record.
  • JS/TS SDK @aiuby-ia/flags with local evaluation: it downloads a snapshot, polls with ETag (304 with no body when nothing changed) and evaluates without a network round trip. Online, cached and offline modes.
  • Every step of the change (request, approval, rejection, cancellation, application, failure and rollback) is recorded in the audit log, and applying goes through the flag.publish policy.
Change with review Protect the environment, view the diff, request the change (now or scheduled), decide and, if needed, roll back. The application reads it with client.getJson('assistente.config', ctx, padrao).
PATCH /api/platform/flags/environments/{env}        { requiresApproval }
GET   /api/platform/flags/flags/{key}/review?environment=&to=&from=
POST  /api/platform/flags/flags/{key}/changes       { environment, version, note, scheduledFor? }
POST  /api/platform/flags/changes/{id}              { action: approve | reject | cancel, note? }
POST  /api/platform/flags/flags/{key}/rollback      { environment, note }

What it does not do

  • The accepted JSON Schema is a subset: pattern, format, $ref, oneOf, anyOf, allOf, not, if and patternProperties are refused with a message. Limits: 16 KB schema, 8 levels and 100 properties per object; each variant value up to 8 KB.
  • Schema and preset are fixed once created. To change the shape, create another key.
  • AIUBY does not call a model with the AI Config or enforce its limits: your application does.
  • There is no SSE: changes arrive by polling. Each flag and environment accepts one open request at a time.

Warehouse experiments

Experiments measured with the numbers your team trusts.

Warehouse analysis uses the data already in your database, instead of asking you to send events again. You write the query that counts exposures and conversions (or sum and variance) per variant, and the platform applies the same statistics used by experiments.

The query reaches the database through the workspace data connector, the same one the other products use: read-only, only on the tables an admin has allowed and over a protected connection. AIUBY receives only the rows aggregated by variant.

How it works

  • Read-only query through the data connector: a validated SELECT, only on the tables allowed in the connector, with up to 200 rows.
  • Conversion (variant, n, conversions) with a Wilson interval, or mean (variant, n, mean, variance) with Welch's test.
  • Bonferroni correction with more than one variant and a small sample warning, with no winner declared when there is no significant difference.
  • Each query goes into the audit log with the SQL and the row count, never with the data.

Example use case

The checkout team records exposure and purchase in its own analytics Postgres. Instead of duplicating events, the analyst writes the query that groups by variant and gets the test result against the control, the interval for each variant and the verdict.

What it does not do

  • It works with Postgres-compatible databases, through the data connector. It does not connect to Snowflake, BigQuery or Trino.
  • The analysis runs on demand and is not saved as a recurring report.
  • It writes nothing to the customer database and does not change the flag: the rollout decision belongs to the team.

Release monitor and flag cleanup

Know whether a change hurt the service, and remove stale flags.

After a flag tied to a service is published or turned off, the release monitor compares the burn rate of that service's SLOs in the hour before and the hour after the latest change. If the after value went above 1 and was at least twice as bad as the before value, the screen suggests the kill switch, with the numbers for both windows.

At the other end of the flag's life, cleanup flags the ones that no longer decide anything: they serve the same variant in every environment, are off in all of them or were never published. For each one, an admin opens a ticket in Code Automation with the exact removal request, and the code change follows that flow, with an approved plan, a tested patch and review by someone else.

How it works

  • Per-flag monitor: a one-hour window before and after the latest change, over the SLI samples of each service SLO; with no samples, the result shows as no data.
  • The suggestion leads to the same turn-off action, with the flag.publish policy and audit; the platform does not turn the flag off on its own.
  • Fixed cleanup rule, with no model: configurable minimum age (7 to 365 days, 30 by default), the reason for each flag, days since the latest change and the latest exposure received in each environment.
  • The same list in the UI, in API v1 (engineering:read) and in the read-only flag_cleanup MCP resource, for assistants and agents to query.
  • Removal ticket: remove the calls that evaluate the key and keep only the path of the variant everyone receives; the acceptance criteria are no references to the key and passing tests.
Through the API The candidate list, through the session and through an API key with engineering:read, with the reason for each flag.
GET /api/platform/flags/stale?minAgeDays=30
GET /api/v1/engineering/flag-cleanup?minAgeDays=30

What it does not do

  • The monitor only suggests and sends no alert: someone has to open the flag to see the comparison.
  • The monitor depends on the flag being tied to a service with an SLO and SLI samples.
  • "No exposure in the period" does not prove the code stopped evaluating the flag: it depends on the SDK sending exposures and on sampling.
  • The platform does not delete or archive flags and does not merge the removal PR: your team owns the merge.

Governance and security

Rules the code enforces

  • In a protected environment, a change only goes in with approval from another admin. Authors cannot approve their own request, and the database refuses it too.
  • Versions are immutable, and every configuration variant is validated against the JSON Schema before it is saved.
  • Publishing goes through the flag.publish policy. Requests, approvals, rejections, applies, failures and rollbacks are all in the audit trail.
  • The kill switch stays direct for emergencies, even in a protected environment.
  • An experiment exposure is only accepted with the signed evaluation token, and the database stores a pseudonym instead of the context key.
  • The SDK key is per environment and shown only once, and generating a new one revokes the previous one. The server credential never reaches the browser.
  • A request whose live version changed since it was opened fails instead of applying a stale diff.

Integrations

What it connects to

Only integrations that exist in the code. Each one carries the status of the feature that uses it.

  • OpenFeatureProviders for @openfeature/server-sdk and @openfeature/web-sdk: your code queries flags through the open standard.Feature flags
  • JS/TS SDK @aiuby-ia/flagsZero-dependency client for browsers and Node 18+, with local evaluation from the snapshot, caching and offline mode.Runtime configuration
  • Prompt libraryAn AI Config references a workspace prompt and its published version.Runtime configuration
  • API v1Reads flags and their state per environment with a scoped key.API, CLI & keys
  • MCP serverFlag state per environment and cleanup candidates (the flag_cleanup resource) are readable by MCP clients, read-only.MCP server
  • Data connectorWarehouse analysis queries your Postgres-compatible database, read-only and only on allowed tables.Warehouse experiments
  • Code AutomationRemoving a stale flag becomes a ticket with an approved plan, a tested patch and a draft PR reviewed by someone else.Release monitor and flag cleanup
  • PoliciesThe flag.publish policy is evaluated on every publish.Governance & policies

FAQ

Straight answers

What can I use today?

Available: Feature flags, Experimentation, Runtime configuration, Warehouse experiments, Release monitor and flag cleanup. Self-service: add it from your account.

Will I need to switch the SDK I use?

Available: Feature flags, Runtime configuration. If your code speaks OpenFeature, no: the SDK ships providers for server and browser, and your queries stay the same. The official SDK is JS/TS. In other languages, evaluation goes through the remote endpoint.

Can a flag outage take my application down?

Available: Feature flags, Runtime configuration. No. The SDK evaluates locally from a snapshot: a network failure keeps the last snapshot, cached mode works with no network, and with no snapshot every query returns the default value your code passed. In the other direction, the kill switch turns the feature off without a new deploy.

Who can change a flag in production?

Available: Runtime configuration. Workspace admins. With the environment protected, direct publishing is refused and the change becomes a request with a required note, which only another admin can approve. Rolling back to the previous version needs no second approver, because it returns to a version that was already live. It does require a note and is audited.

Which statistical tests do experiments use?

Available: Experimentation. For conversion, a two-proportion z-test with a Wilson interval per variant and a Wald interval for the difference. For means, Welch's test. With more than one variant against the control, the Bonferroni correction applies, with α = 0.05. With fewer than 30 contexts per variant, or fewer than 5 successes or failures in a conversion, the report warns that the sample is small. Without significance after correction, no winner is declared.

Can experiments analyze data in my data warehouse?

Available: Warehouse experiments, Experimentation. They can, if the database is Postgres-compatible. Warehouse analysis runs your read-only query through the data connector, on allowed tables, and applies the same experiment statistics to the rows aggregated per variant. The audit trail keeps the SQL and the row count, never the data. Snowflake, BigQuery and Trino are not connected. Without the warehouse, the report uses the exposures and events your application sends, kept for 90 days with the context key replaced by a pseudonym.

Does the platform switch a flag off on its own when the service degrades?

Available: Release monitor and flag cleanup. No. The release monitor compares the burn rate of the service SLOs in the hour before and the hour after the last flag change, and suggests the kill switch when things got worse. Switching off remains an admin action, with policy and audit. Likewise, cleanup points to flags that serve a single variant and opens a Code Automation ticket to remove them from the code, but the platform never deletes or merges anything.

How much does it cost?

Available: Feature flags, Experimentation, Runtime configuration. This product has no published price. When it does, it will appear on the Pricing page.

Works together with

  • AI EngineeringAn AI Config points to a prompt in the workspace prompt library, and the referenced version must be published there.
  • Engineering IntelligencePublishing a flag emits the flag.rollout.changed event, and flag state per environment is readable through the engineering API.

Feature Management

Self-service: add it from your account.