Changelog

We’ve created a Reflag node for n8n, enabling you to use Reflag in your automated and agentic workflows.

n8n is a workflow automation tool. You can use it to implement multi-step AI agents and integrate with hundreds of apps. Now you can connect Reflag too, with our community node.

The Reflag node supports all the same end-points as our REST API, including the ability to list applications, get details of an app, list flags for an app, as well as get and update flag targets.

This means you can integrate your back-office systems with Reflag's flag targeting. By using the Reflag node, you can provide access to specific flags for a company or user directly from your systems.

To get started, you’ll need to generate an API key, and add it to the Reflag node credentials. For more information, check out the node package on npm.

Last week, we added flag icons in Reflag. Now, to make recognizing projects across Linear and Reflag easier, we’ve added icon syncing.

For flags with an associated Linear issue or project, the same icon and color used in Linear will be set for the flag in Reflag. If you change your mind, any icon changes made on Linear are reflected on Reflag, too.

Since Linear’s icons are custom, the icon graphic won’t match the one used in Reflag exactly. There are also some icons we don’t have equivalents for.

If you’ve already connected Linear with Reflag, syncing is live now, so you’ll start to see matching icons appearing for the flags with a connected Linear project or issue.

Otherwise, to get started, you can integrate Linear with Reflag from the Integrations page under Settings or check out the docs.

If you don’t want to use the same icon, you can still set your own flag icon in Reflag. Icon syncing is disabled when you manually pick a flag icon.

To make flags more recognizable and to help you better organize them, we’ve added flag icons.

You can now select a custom icon for any of your flags. Choose from 230 icons or 1,800+ emojis to capture the right look and feel.

Each icon can be set with one of 9 preset colors, or any hex color code you like, and we’ll automatically adjust the contrast to fit your chosen theme.

To set an icon, head to Settings for that flag under Flags, and click on the icon box next to the Name field.

The UI is clearly inspired by Linear - for good reason... we now sync icons from Linear, too.

Happy flagging!

We’ve added Cursor rule and custom slash command templates to our docs, so you can get the coding agent to create a new flag and wrap the code it creates with it.

Cursor recently added the ability to create custom Slash commands, which are reusable prompts for common requests. You can create one to flag your code, using /flag in the Agent input and selecting the command from the dropdown menu.

Better yet, add a Cursor project rule to flag your code. Rules provide persistent, reusable context at the prompt level. Project rules are stored in `.cursor/rules`, are version-controlled, and scoped to your codebase.

To get started, check out the templates in our docs.

We’ve added support for Customer Requests to our Reflag agent for Linear. Now you can give customers early access when their request is shipped.

Reflag agent for Linear enables you to create and manage feature flags and update access rules directly from Linear.

We now include Customer Requests in the context we give to the Reflag agent, so it’s able to act on it. For example, on a Linear issue, you can add a comment saying:

@reflag flag this feature and release it to the customers that requested it.

Reflag agent will create a feature flag for you, and set the access rules to include the requesting customers. Don’t worry, we take care of matching customers on Linear to the companies you have in Reflag.

This addition makes Linear customer requests actionable, saving you from having to create a flag yourself, as well as lookup and add the customers you want to give early-access to.

To get started with Reflag agent for Linear, check out the integration page or read the docs to begin using it.

We shipped support for API keys so you can use the Reflag CLI within CI/CD pipelines and with coding agents.

Available in Settings under SDK & API keys, the page lists SDK keys (known before as "Environment Keys") that you can use when configuring our SDKs in your product. This page also includes the ability to create API keys, which allow access to the Reflag REST API.

API keys currently support 3 scopes: read-only, create flag, and update flag targeting. They enable you to run the Reflag CLI where auth is needed in automated environments, like CI/CD pipelines and background coding agents.

The keys used to be available in a few different places within Reflag web app, so we took the opportunity to consolidate them in one spot.

Check out our docs article for full details on how to use Reflag with CI/CD pipelines, as well as our API access docs, too.

We’ve added support for server-side rendering with bootstrapped flags for faster initial page load times.

With getFlagsForBootstrap() in the Node SDK and ReflagBootstrappedProvider in the React SDK, you can evaluate flags on the server and pass them to your client-side applications.

This eliminates the loading delay that users experience when flags are fetched on the client. With bootstrapped flags, they’re evaluated server-side and immediately available when your app loads.

How it works

On your server, use getFlagsForBootstrap() to get serializable flag data:

const client = new ReflagClient();
await client.initialize();

const { context, flags } = client.getFlagsForBootstrap({
  user: { id: "john_doe", name: "John Doe" },
  company: { id: "acme_inc", name: "Acme, Inc." },
  other: { location: "US", platform: "web" },
});

Then on the client, use ReflagBootstrappedProvider instead of the regular ReflagProvider:

function App({ bootstrappedFlags }) {
  return (
    <ReflagBootstrappedProvider
      publishableKey="your-key"
      flags={bootstrappedFlags}
    >
      <YourApp />
    </ReflagBootstrappedProvider>
  );
}

Your flags are now immediately available without any loading state:

function FeatureComponent() {
  const { isEnabled } = useFlag("new-feature");
  return isEnabled ? <NewFeature /> : <OldFeature />;
}

Beyond faster initial page loads, bootstrapped flags can help with SEO as search engines see the correct content immediately as well as improved UX with no loading flicker when features conditionally render. It also works with static generation to evaluate flags at build time for static sites.

The method returns raw flag data without wrapper functions, making it JSON serializable for easy server-to-client transfer. You can also use it with a bound client for simpler APIs:

const boundClient = client.bindClient({
  user: { id: "john_doe" },
  company: { id: "acme_inc" },
});

const bootstrappedFlags = boundClient.getFlagsForBootstrap();

For more details, check out the updated Node SDK docs and React SDK docs.

Flag ownership is important for accountability and internal communication, and it’s now easily managed in Reflag.

Flag ownership helps address questions like: Who’s responsible for moving this out of Beta? Or, who will clean up and archive the flag once rolled out?

So now you can set an owner for each flag on Reflag, and the new “My flags” view makes it easy to find the flags you own.

You can also find flag owners using the search bar, too:

‍

When Linear first shipped support for agents on Linear, we were a launch partner. Linear have high standards for how interactions should work, but the details were left up to ourselves. Recently, Linear shipped their Agent Interaction SDK which codified the interaction patterns that emerged during the initial agent implementation phase.

The Agent Interaction SDK comes with much better support inside Linear for working with agents. We've implemented it, and now using Reflag agent in Linear is a super smooth experience:

The Linear team added a way to show that the agent is working, and it also now keeps a history of what the agent did.

Implementation-wise, we previously needed to keep a bunch of state on our side to ensure that the agent had full context for follow-up messages. That's now handled by Linear, too, making our implementation much simpler to maintain.

To learn more, check out our integration page on Linear, or read the docs.

Remote config allows you to change app behavior without having to re-deploy. For example, you can use configs to provide some accounts with a stable LLM model while others get a newer, experimental one.

We’ve added advanced targeting rules to configs. Just like on the Access tab, you can now target based on advanced filters, like company or user attributes, feature access, and other context. 

Here’s an example remote config: All accounts get the 1st variant, GPT-4o, except those who get variant 2, GPT-5.

We also polished the UI and, in response to feedback, revised some of the terms to make it more intuitive to work with.

Happy shipping!