Fluid

AI research, emerging models and ideas reshaping tomorrow.

[Fluid @fluid_ai_]

@0xLotttus The reviewer is arguably the most important agent in the entire workflow

separating generation from verification reduces silent errors, and independent models can help catch shared blind spots

In reliable AI systems, validation is just as important as generation

[Fluid @fluid_ai_]

@Bhavani_00007 DeepSeek V4.1 Flash 1017 looks like a solid step forward, especially with its speed and improved capabilities

with further refinement in visual consistency and 3D generation, it could become a serious competitor

[Fluid @fluid_ai_]

THE COST OF AN IMAGE JUST WENT TO ZERO AND ALMOST NOBODY RAN THE NUMBERS

Black Forest Labs dropped FLUX 3 Image Klein on Oct 15. Open weights. 5.6B params. Runs on a single consumer GPU.

The announcement says “fast” and “consumer GPU.” It doesn’t say the part that actually matters:

for most people reading this, image generation just became a fixed cost instead of a per-unit cost.

here’s what shipped:

- 5.6B params - the smallest model in its own comparison chart (Qwen-Image 2.1 is 7B, Krea 2 is 12.9B)
- native 4K output
- bounding boxes - draw the region, the model edits only there
- pixel-perfect editing - unedited regions preserved exactly
- multi-reference generation with up to 10 reference images
- base model for fine-tuning + a step-distilled model for latency
- FP8, INT8 and NVFP4 builds made with NVIDIA
weights are 11.2 GB in BF16, 5.6 GB in FP8. the INT8 build runs on RTX cards with as little as 8 GB VRAM through ComfyUI or Diffusers.

The real numbers, 1024x1024, 16-step distilled:

RTX 5090 - 4.1s generate / 7.2s edit
RTX 4070 - 8.9s generate / 18.9s edit
GB300 in NVFP4 - under 0.6s
an RTX 4070 is a card people already own. that’s the whole story.

Now the part the launch post skipped - the license.
it’s the FLUX Kommunity License. free commercial use for individuals and companies under $5M annual revenue.

Read that again if you’re a solo operator. you are not the exception to this license. you are the target of it.

The money math, 1,000 images at 1K:

Nano Banana 2.1 - $33.60
Krea 3 - $30.00
Klein via BFL API - $9.00
Klein on your own GPU - $0.00 plus electricity

At 4K the API gap holds: $0.036 vs $0.113.

But the API isn’t the point. the point is the fourth line.

When generation costs you nothing per image, you stop budgeting attempts. a product shoot stops being “pick the three best angles” and becomes “render forty, keep what converts.” a thumbnail stops being a decision and becomes a test.

and because you can LoRA it - Ostris’s AI Toolkit and NVIDIA NeMo AutoModel both work on day one - you can train your own face, your own product, your own style, and never rent that likeness from anyone.
that’s the actual unlock. not speed. ownership.
now the honest part, because the charts are doing some work:

- the benchmarks are BFL’s own internal evals. methodology isn’t published.
- their comparison chart omits GPT Image 2.5 and Nano Banana 2.1 - the exact two models everyone actually benchmarks against. that omission is a choice.
- the 8 GB VRAM claim isn’t tied to a variant, an output size, or a generation time. the speed charts don’t test 8 GB configs at all, and don’t test 4K.
- “native 4K” is real but not fast at home: 2048x2048 editing is 43s on a 5090 and 150s on a 4070. 4K at consumer speed is still a cloud job.
- the $5M revenue test is gross annualized revenue combined with affiliates. if you run multiple entities, read the terms that ship with the download, not a blog post about them.

None of that kills it. it just means the headline is “a very good free model you own” and not “frontier quality for free.”

What I’d actually do this weekend:

Pull the INT8 distilled build into ComfyUI. that’s the configuration the speed numbers describe.

train one LoRA on the thing you sell most - your product, your face, your mascot. that’s the asset. the model is just the engine.

Run your own bake-off against whatever you currently pay for, on YOUR prompts. BFL’s Elo is not your use case.

Check the license terms in the download before you ship commercial work. not the summary. the file.

Weights: https://t.co/kl3vVuf7it

Code: https://t.co/WVAzaogg5c
Writeup: https://t.co/yNe13xktaj

The people who made money on the last image-model cycle were the ones who stopped renting and started owning.

This is the cheapest that door has ever been.

bookmark it.

[Black Forest Labs @bfl_ai]

FLUX 3 Image Klein is here.

Open Weights with the quality of a large frontier model. Customizable and fast.

5.6B parameters and runs on a single consumer GPU.

Native 4K, bounding boxes, and pixel-perfect editing.

[Fluid @fluid_ai_]

7.89 SECONDS. THAT’S THE WHOLE STORY

Krea opened the Krea 3 beta today, and the number that matters is buried in their own benchmark.

end-to-end 2k edit, same quality tier:

- Krea 3 - 7.89s
- grok-imagine-image - 18.4s
- Nano Banana 2 - 18.7s
- Nano Banana 2.1 - 23.9s
- Nano Banana Pro - 24.4s

three times faster than the model everyone has been calling the ceiling.

most people will read that as “nice, it’s quicker.”

that’s the wrong frame. at this level speed stops being convenience and starts being a business model.

here’s the math nobody runs:

at 24s per edit you iterate. you try a version, wait, judge it, try again. a batch of 50 creatives is 20 minutes of staring at a loading bar, so you ship three variants and call it done.

at 8s per edit you produce. the same 50 creatives land in under 7 minutes. you stop rationing attempts. you stop pre-judging ideas in your head because waiting is expensive.

the bottleneck moves from the model to you.

what actually shipped:

- end-to-end 2k edits in under 8s
- bounding box control - you draw the region, the model edits only there
- precise multi-turn edits - the image survives a chain of changes instead of melting on turn four
- quality Krea puts level with Nano Banana Pro and GPT Image 2.5

the multi-turn part is the quiet one. every editing model can do one good edit. almost none hold the subject’s face through six consecutive instructions. that’s the thing that makes a character consistent across a whole campaign.

bounding box control is the other half. “change the jacket, touch nothing else” used to be a prompt you begged for. now it’s a rectangle.

where the money is:

product photos - one shot, fifty backgrounds, under 10 minutes
ad creatives - same hook, twenty variants, test all of them
AI characters - a consistent face across an entire content calendar
thumbnails - iterate until CTR moves, not until patience runs out
the people making real money off image models aren’t the ones with the best prompts. they’re the ones running the most iterations per hour.
this just tripled that number.

beta is open now - https://t.co/et80PxxkG4

one caveat before you quote the numbers at someone: this benchmark is Krea’s own. run your own test on your own workload before you rebuild a pipeline around it.

save this. the speed tier just moved, and the pricing on everything else moves next.

[Krea @krea_ai]

today we open the beta for Krea 3, a new frontier for image editing.

- end-to-end 2k edits in under 8s.
- matches Nano Banana Pro or GPT Image 2.5 quality.
- bounding box control and precise multi-turn edits.

learn and get access 👇

[Fluid @fluid_ai_]

The real breakthrough isn’t AI generating profitable signals, but combining reasoning models with market data, rigorous backtesting, and execution controls

A 3day PNL proves little without out-of-sample validation and risk-adjusted returns

That’s where AI quant systems can create a lasting edge

[Fluid @fluid_ai_]

THIS QUIETLY KILLS THE CHAT WINDOW

https://t.co/vKvnGjWbhh open-sourced Agent-Native yesterday and the architecture is the actual story here.

Every agent product today picks one of two losing sides.

Side one: a chat box with no interface. The agent returns a wall of text and the human scrolls through it hoping nothing broke.

Side two: an app where the agent clicks buttons through screenshots like a confused intern. One CSS change and the whole run dies.

Agent-Native kills both.

The core idea is a single function:

defineAction()

You define a capability once. That one definition becomes six things at the same time:

- a UI control your frontend calls from code
- a tool the agent sees as JSON Schema and can call in chat
- an HTTP endpoint
- an MCP tool, so Claude and other MCP hosts can call it
- an A2A capability, so other agents can call it
- a CLI command

Write the feature once. Ship it on six surfaces.
Here’s the detail almost everyone is missing:
The agent never clicks through your UI.

It receives UI state instead - the current page, the selected record, the active view - and acts through the action layer. No screenshots. No flaky selectors. No “the button moved two pixels and the agent broke.”

Both sides write to one SQL database. Work the agent does appears in the interface. Work the human does in the interface is available to the agent. There is no second hidden system drifting out of sync.

the full tree

defineAction defines the capability once
UI calls the action directly from code
agent calls the same action as a tool
HTTP, MCP, A2A and CLI expose it without extra work
shared SQL state keeps both views aligned
every mutating action is audited: who, when, from which surface

What ships with the framework:

Agent chat, so people delegate work and review results in the same UI

Automations that run agent work on schedules or events

Agent teams that hand work to specialist agents across connected apps

A gallery of complete apps to fork - a Loom clone, a
Figma-style design tool, an analytics tool, a Notion-style content app
Not empty starters.

Working products.

The stack is deliberately unopinionated: any SQL database Drizzle supports, any host Nitro supports, and your choice of agent - Claude Code, Codex, Gemini CLI, OpenCode or https://t.co/vKvnGjWbhh.

MIT licensed. Commercial use allowed. You can keep your own code closed.

Start here:

npx @agent-native/core@latest create my-app
cd my-app
pnpm install
pnpm dev

Then paste this into Claude Code

"Read the Agent-Native docs at https://t.co/lz97J5OIA0, then restructure my app around the action layer:

1. Find every capability in my codebase that exists twice - once for the UI and once as an agent tool.

2. Collapse each pair into a single defineAction() definition.

3. Expose each action on UI, HTTP, MCP and CLI without duplicating logic.

4. Move agent context from screenshots to UI state: current page, selected record, active view.

5. Put UI and agent writes on the same SQL tables so neither side holds hidden state. Show me every change as a diff first. No edits until I say go."

Source: https://t.co/k9IZXLOtSj
Docs: https://t.co/lz97J5OIA0

The UI shows what the agent can do. The agent does it. The human approves.

Save this one. You’ll be rebuilding your agent around it.

[Steve (Builder.io) @Steve8708]

Introducing Agent-Native: an open-source framework for building agentic apps.

Agents love walls of text. But humans don't.

An agentic app let's you interact with agents through a visual interface. Engage with agents visually, via text, or both at once.

Now in beta.

[Fluid @fluid_ai_]

@Polymarket OMG!!