LLMs today are incredible for writing articles or generating code. But one area where I don’t see them get used often is finance. It’s just way too risky, I guess. A single hallucinated cell reference can cascade through an entire valuation sheet and destroy your discounted cash flow analysis.

Subscribe now

Financial workflows leave little room for that kind of error. Misreading an accounting disclosure or using the wrong revenue denominator can change the conclusion even when the output looks convincing.

I wanted to see how a specialized model would handle these constraints. Instead of just running a few prompts in a chat window, I built a custom Next.js web application to test Ling 3.0 Flash Fin with sourced financial data, a browser workbook, and tools for reviewing financial disclosures.

Personally, I find this more useful than judging a model from a chat response alone. Having the numbers, charts, and source material beside the answer gives me something concrete to check.

This article is a breakdown of what the model actually is, how I wired up the application, and the results from three demonstration workflows.

Before I get into the details, here’s a demo of how each module works using the Ling 3 Flash Fin API:

What Is Ling 3 Flash Fin?

Ling 3.0 Flash Fin is a finance-focused model built through continued training of Ling-3.0-flash on financial data. Its stated use cases include financial research, reasoning across documents, valuation, and spreadsheet workflows. The official model card describes 124 billion total parameters with 5.1 billion activated parameters.

The model is competitive with both similarly sized models and substantially larger general-purpose models, with particular strength in source selection and tool-intensive financial tasks.

That made it an interesting candidate for this experiment. I wanted to see whether it could interpret financial categories, explain workbook updates, and recognize when a disclosure didn’t contain enough information to support a calculation.

I accessed the model through OpenRouter, using the model identifier inclusionai/ling-3.0-flash-fin:free. That’s the model used throughout the application.

If you prefer local inference, the official checkpoint is available on Hugging Face, and there are community GGUF quantizations, including bartowski’s Ling-3.0-flash-Fin-GGUF. Running those requires suitable hardware and a compatible runtime.

For this project, I used the API. That kept the setup manageable and let me focus on the application. Requests in this version go to an external provider; I didn’t test local inference.

Let’s Talk About the API Access

Financial applications need to handle network errors and slow responses clearly. A request that times out shouldn’t leave a result panel looking as though an analysis succeeded.

I centralized the browser’s model requests in lib/openrouter.ts. Every request goes through the Next.js route at /api/openrouter, which attaches the authorization and attribution headers before contacting OpenRouter.

The browser calls the internal API route, keeping the OpenRouter key on the server.

Here is the core request setup, excerpted from the server route. The surrounding code validates the incoming request, checks whether the key is configured, and returns upstream errors to the browser:

// app/api/openrouter/route.ts — request setup excerpt
const apiKey = process.env.OPENROUTER_API_KEY;

const payload: Record<string, unknown> = {
  model: LING_MODEL_ID,
  messages,
  max_tokens: 16000,
  temperature: 0.2,
};

if (tools && Array.isArray(tools) && tools.length > 0) {
  payload.tools = tools;
  if (tool_choice) {
    payload.tool_choice = tool_choice;
  }
}

const openRouterResponse = await fetch(
  “https://openrouter.ai/api/v1/chat/completions”,
  {
    method: “POST”,
    headers: {
      Authorization: `Bearer ${apiKey}`,
      “Content-Type”: “application/json”,
      “HTTP-Referer”: req.headers.get(”origin”) || “http://localhost:3000”,
      “X-Title”: “Ling 3 Flash Fin Demo”,
    },
    body: JSON.stringify(payload),
    signal: AbortSignal.timeout(110000),
  },
);

LING_MODEL_ID is set to inclusionai/ling-3.0-flash-fin:free.

The server request has a 110-second timeout, while the browser request has a 120-second timeout. Empty responses and completions cut short by the token limit produce errors rather than accepted analyses.

This gives the terminal a clear error state if a request takes too long or returns an incomplete response. It sounds like a small implementation detail, but I don’t want to wonder whether a financial explanation stopped halfway through.

How I Built a Web App With the API

I wanted this to feel like a real desktop financial terminal. I used Next.js 15 with the App Router alongside Tailwind CSS for styling and Recharts for the data visualizations.

Here’s the end-to-end system architecture in case any devs out there are interested:

The chart displays the supplied financial data, and the workbook runs its calculations in application code. Ling analyzes those inputs and requests supporting evidence through the research tools.

One of the most annoying parts of building AI user interfaces is handling unconstrained container growth. You send a prompt, and the model returns two thousand words of dense Markdown. The default web container stretches vertically and ruins your layout.

To fix this, I built a custom Markdown viewer component. Its rendering wrapper looks like this:

// components/MarkdownViewer.tsx — rendering excerpt
return (
  <div
    className={cn(
      “custom-scrollbar overflow-y-auto pr-2 text-xs leading-relaxed text-slate-200 font-sans select-text space-y-1”,
      maxHeight,
      className
    )}
  >
    {elements}
  </div>
);

I paired this with a custom scrollbar design in my global CSS. The application constrains its height and lets long responses scroll internally. The workspace stays contained and feels like a native app.

I like having the analysis and the evidence visible at the same time. Scrolling back and forth through a long conversation makes it too easy to lose track of which number the model is discussing.

With the architecture in place, I ran the model through three distinct workflows to see where it would break.

Demo 1: Finance Report and Visualization

First up was financial report and disclosure analysis. Equity research footnotes contain multibillion-dollar nuances that can change how you interpret a company’s revenue.

I tested the model on NVIDIA, comparing Hyperscale with ACIE, which stands for AI Clouds, Industrial, and Enterprise.

The app uses a manually transcribed snapshot from NVIDIA’s Q2 FY2027 filing, reviewed on September 10, 2026. The chart and the model receive the same underlying figures. There’s no live web search in this module.

Query: Analyze NVIDIA growth drivers. Calculate Hyperscale and ACIE year-over-year growth and shares of Data Center revenue. Explain the recast and distinguish observed revenue growth from hypotheses about demand. What does this evidence not tell us about margins or end-customer concentration?

There is an important reporting detail here. NVIDIA reclassified a customer from ACIE to Hyperscale in Q2 FY2027 and recast prior periods. To compare growth consistently, the app uses the historical figures presented on that same reporting basis.

This is important because a category can appear to grow simply because its definition changed. I wanted the comparison to reflect revenue growth across equivalent categories.

Here are the checked calculations from the test:

From FY26 Q2 to FY27 Q2, Hyperscale revenue grew 101.55%, while ACIE grew 138.14%. Data Center revenue increased 116.62%, so it more than doubled.

The category shares use Hyperscale plus ACIE as the Data Center denominator. Edge revenue sits outside that subtotal and is included in total company revenue.

ACIE’s share increased from 41.19% to 45.28% over the year. Both categories grew substantially, but ACIE grew faster on this recast basis.

I requested structured calculations through a submit_analysis function schema so the application could check the numbers before displaying them.

The app checks the returned periods, subtotals, shares, and growth rates against its own calculations. Incorrect or incomplete fields trigger a visible validation error. This function provides a structured output format for the analysis.

The interface displays checked calculations separately from the model’s interpretation, which still requires review.

The supplied snapshot supports comparisons of revenue and category mix. It doesn’t establish category margins, individual customer concentration, or why demand changed. Those questions require additional evidence, even though the full filing contains information beyond the small table passed to Ling.

Revenue growth is observable here. An explanation involving pricing, product mix, or customer demand needs evidence of its own.

The right pane presents Hyperscale in green and ACIE in cyan using interactive Recharts bar charts. This lets me compare Ling’s explanation with the financial data alongside it.

Demo 2: Financial Modeling in a Browser Workbook

The second test combined application calculations with a model-generated workbook review.

I loaded an Alphabet 2026 Q2 revenue workbook into the application. It has three browser views: Summary, Q2 Actuals, and Projections. It contains seven revenue and hedging rows, with the calculations running directly in the browser.

The historical figures come from Alphabet’s 2025 annual revenue table, and the quarterly figures come from its Q2 2026 earnings release.

FY2024 revenue totals $350,018 million, FY2025 totals $402,836 million, and Q2 2026 totals $119,796 million. The quarterly release is unaudited.

The rows include Google Search & other, YouTube ads, Google Network, subscriptions/platforms/devices, Google Cloud, Other Bets, and hedging gains or losses. Including hedging is necessary to reconcile these categories to consolidated revenue.

Alphabet reports segment results as Google Services, Google Cloud, and Other Bets. Search, YouTube, Network, and subscriptions are components of Google Services. The workbook presents revenue categories that add up to the company’s total.

Clicking Execute Update & Review maps seven actual values into Summary. Application code recalculates the Summary total, seven Q3 scenario values, and the scenario total. Ling then receives the workbook data and explains the mapping and variances.

If the model request fails, the app reports that separately from the completed workbook update.

With the illustrative growth assumption set to 10%, the formulas are:

Q2 estimate = round(Q2 2025 actual × 1.10)
Variance = Q2 2026 actual − Q2 estimate
Q3 scenario = round(mapped Q2 2026 actual × 1.10)
Total = sum of all seven rows

The estimates totaled $106,070 million, producing a positive variance of $13,726 million against Q2 actual revenue. The rounded Q3 scenario values totaled $131,776 million.

Google Cloud had the largest positive variance at $9,782 million. Google Network and Other Bets had negative variances of $786 million and $28 million respectively. These are differences against an illustrative assumption, not surprises against analyst consensus.

The Q3 scenario applies the assumption quarter over quarter. It is a way to explore a possible outcome, rather than company guidance or an analyst forecast.

I like keeping the assumption visible in the interface. A projection can look surprisingly authoritative once it sits in a neatly formatted table, even when it comes from something as simple as applying 10% to the previous quarter.

Corporate financial models are networks of connected calculations. This small workbook demonstrates three of the operations involved:

1. Actuals mapping: Move sourced quarterly values into the active-period view.

2. Estimate replacement: Change the active values from an illustrative estimate to the corresponding actuals.

3. Dependency recalculation: Update totals and scenario values that depend on those inputs.

I was pretty satisfied with how this worked. The application handled the mappings and recalculations, while Ling supplied a review of the workbook and the assumptions behind it.

Demo 3: Financial Evidence Review

The final test was a tool-assisted financial research task using Spire Inc., the natural gas company listed on the NYSE as SR, with CIK 0001126956.

Spire classified its Marketing and Storage businesses as discontinued operations, as described in its July 2026 disclosure. I wanted to see whether Ling could identify those businesses from the supplied disclosures and explain what information was needed to rebuild historical continuing-operations earnings.

Notice the three-column technical implementation:

1. Tool-call terminal: Records model-requested read_filing calls, their source IDs, and completion or failure status. The count reflects the calls executed during the run.

2. Evidence viewer: Shows the text returned by each successful call, a source link, and whether the result is an offline summary or a live excerpt.

3. Model findings: Displays Ling’s analysis, its explanation of the accounting treatment, and any missing evidence needed for a calculation.

The browser orchestrates a bounded agent loop. It forwards model requests through the server proxy, dispatches requested source reads to /api/sec-edgar, and returns their results as tool messages. The loop allows up to six model turns and 12 source-tool calls before reporting an incomplete run.

For this sample, I selected the default offline mode. Ling requested both available sources, and the log recorded two completed calls. Each call returned a curated source summary for the model to read.

The summaries cover the July recast disclosure and relevant portions of Spire’s June 30, 2026 Form 10-Q. They establish the discontinued-operation classification but omit the numerical income and disposal-group tables.

Here’s the task I gave the model:

Query: For Spire Inc. (NYSE: SR), establish which businesses are discontinued and explain how to rebuild FY2025 continuing-operations earnings on the recast basis. Read both available sources. Calculate historical profit only if the source tables contain all required amounts, identify the exact period and units, and show the arithmetic. Otherwise identify the missing evidence.

Ling identified Storage and Marketing as discontinued operations. It also stated that the summaries lacked the figures needed to calculate historical profit.

A valid reconciliation would need consolidated net income and discontinued-operations income for the same entity, period, and after-tax basis. At that level, the relationship is:

Continuing-operations net income
    = Consolidated net income
    − Income from discontinued operations, net of tax

If discontinued operations reported a loss, subtracting that negative amount increases continuing-operations net income.

Continuing-operations net income is also different from EBIT or an adjusted non-GAAP measure. Sale proceeds alone can’t fill those gaps, and a calculation needs to use the financial measure requested.

This is why I wanted the evidence viewer in the middle of the screen. I want to be able to read what the model received before deciding whether its conclusion follows from it.

The application also has an optional live SEC mode. It requires a SEC_USER_AGENT value identifying the organization and contact email. The server fetches only the allowlisted filings and extracts bounded HTML text excerpts. It doesn’t parse XBRL or read numbers embedded in slide images.

For the run shown here, I used offline summaries because live SEC requests from my environment returned HTTP 403. The result demonstrates source review and identification of missing evidence; calculating historical profit would require the numerical schedules as well.

By the way, I have open-sourced the project. The GitHub repository is here:

https://github.com/jimclydegm/LingFinance

Why Should You Care?

If you build fintech applications or work in equity research, you already know the pain of using LLMs for math-heavy tasks.

A convincing explanation isn’t enough. Revenue needs to reconcile, spreadsheet assumptions need to be explicit, and accounting conclusions need to trace back to the right disclosures.

Ling 3 Flash Fin produced useful financial explanations and requested the source tools provided to it. The application made those results easier to inspect by placing the evidence, calculations, and commentary together.

To me, that is a practical starting point for financial AI: tasks small enough to check, with enough context for the model to contribute something useful.

That makes this approach worth testing for the repetitive parts of financial research. The calculations still need independent checks, and the interpretations still need review.

Final Thoughts

Alright, I hope you found this demo interesting and also learned how the Ling 3 Flash Fin API works.

Building this Next.js terminal gave me a practical way to explore a domain-specific model. I could inspect the financial inputs, see which tools it requested, and compare its calculations with values generated by the application.

In the examples above, Ling analyzed NVIDIA’s revenue mix, reviewed an Alphabet revenue workbook, and identified the evidence needed for a continuing-operations earnings calculation. Those are useful starting points if you are building an automated financial research tool.

I’m interested in where this kind of application can go, especially when the source material and calculations are easy to inspect. That makes it much easier to decide which parts of a workflow are ready for automation and which still need a person looking closely.

What do you think of Ling 3 Flash Fin’s API? Do you think this would be helpful in the finance industry? Let me know what you think.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

On September 8, AI researcher Jacob Coxon resigned from Anthropic. The next day he posted a seven-part thread on X explaining why, and it hit 90 million views in under 24 hours.

Subscribe now

Most AI doom warnings come from people who have never been near a training run. Coxon spent three years doing…

Read more

For the certified otakus reading this, have you ever created an original anime character and then wanted to see that same character in a different pose, outfit, or setting?

Some of my friends have tried doing this with ChatGPT and Gemini. They can produce good anime images, but the results are not always the version of the character they had in mind.

Subscribe now

As an AI enthusiast, I went looking for a tool built more specifically for this use case. One that I recommend trying is PixAI, an AI creative platform focused on anime art. It includes image generation and editing tools, anime models, community LoRAs, character references, and other workflows for developing original characters.

PixAI recently introduced Tsubaki.3, its newest anime image model. It can take a character reference image, identify important visual traits, and reinterpret the subject across new poses, outfits, camera angles, and scenes. Tsubaki.3 is still in early access at the time of writing, so it may not yet appear on every account.

In this guide, I will show how the new reference workflow works, including single-character edits, multi-character replacement, pose transfer, and turning a 2D character into a figure-style render.

Let’s get started.

What’s New in PixAI?

Let me start with PixAI’s redesigned image generator dashboard. Reference images can now be dropped directly into the prompt area instead of being managed through a separate part of the interface. I find this layout much easier to follow because the images and instructions are kept in one place.

The new dashboard also felt faster and more reliable during my tests. After uploading an image, I could refer to it inside the prompt by typing @ and choosing the corresponding file. This becomes especially useful when working with several references because I can tell PixAI exactly which image contains the character, outfit, pose, or base composition.

The older generator has not disappeared. Clicking Switch to Classic Editor returns to the previous dashboard for anyone who prefers that workflow or needs an option that has not yet moved to the new interface.

The other major addition is Tsubaki.3. PixAI designed the model to support more of the anime creation process rather than producing unrelated one-off images. According to the official Tsubaki.3 showcase, one reference can be enough for the model to extract a character’s traits and place that character in a new scene.

Its key capabilities include:

• Reference-based character generation: Upload an existing character and reuse their identity without training a separate model first.

• Character and style consistency: Preserve recognizable facial features, hair, accessories, and the broader visual style across different outputs.

• Outfit, pose, and scene control: Combine a character from one image with clothing, body positioning, or an environment taken from another.

• Single-character and multi-character compositions: Give each character a separate reference and identify them individually inside the prompt.

• Creative production formats: Generate expression sheets, turnarounds, manga panels, stickers, alternate lighting setups, and figure-style renders.

This turns Tsubaki.3 into more than an AI character reference generator. It can also work as a consistent anime character generator for creators who need the same subject to survive several visual changes without being redesigned every time.

Okay, now let’s move on to the new features that you can play with.

Maintain Character Features Across New Scenes, Outfits, and Compositions

The first workflow I tested was an outfit transfer. I wanted to keep the identity of the character in the first image but dress that character in the clothing shown in the second image.

Here are the reference images and the prompt I used.

Prompt: Keep the head features of the character in Image 1 unchanged, and only replace their clothing with the clothing from Image 2.

Upload these two images along with the text prompt on the image generator tool. This is what your dashboard should look like:

Notice how I am tagging the reference images; just type “@” and select the reference image. Submit and wait for the final image to be generated.

Here are the two sample versions:

I like that the two versions do not feel like duplicates. One stays very close to the original character, while the other allows more of the second reference’s styling to influence the result. Both still preserve the features I cared about instead of producing a completely new person wearing a similar outfit.

This is useful when developing alternate costumes for an original character. A creator could start with one approved design and test a school uniform, formal outfit, battle costume, or seasonal variation without rewriting the entire character prompt. The reference carries the identity while the instruction explains what is allowed to change.

Single-character and multi-character references

Keeping one character consistent is already difficult, but a scene with two characters introduces another problem. Their traits can blend together.

Hair colors move from one subject to another, outfits become mixed, or the model changes both characters even though only one was supposed to be replaced.

Tsubaki.3 lets me attach separate reference images and assign each one a specific role. In the example below, I used a two-character image as the base composition, then uploaded another character to replace only the person on the left.

Here’s an example:

This is the sample shortened prompt used:

Prompt: “Using as the base, perform a character replacement. Preserve the overall composition, camera angle, urban street background, sunny natural lighting, and the close, friendly photo-taking interaction between the characters in . Keep the character on the right completely unchanged, and only replace the character on the left side of with the character from”

The replacement character sits naturally inside the original composition. The camera angle, street background, lighting, and interaction between the two subjects remain close to the base image.

More importantly, the character on the right was not redesigned while PixAI worked on the left side.

The replacement also retained the details that made the source character recognizable, including the face, dress, eyepatch, hair, and accessories.

This is the kind of result I would want from consistent character AI because it follows the requested division of work. One character changes while the rest of the scene remains stable.

Being able to tag each reference separately also makes multi-character projects easier to organize. I do not have to generate every subject in the same conversation or combine them manually before uploading.

I can provide one clean image for each character, use another image for the composition, and state which person should appear in each position.

Using a Separate Pose Reference

The same tagging system can be used for poses. I can upload an already finished character illustration as @image1, then attach a sketch, photograph, or 3D mannequin as @image2. The second image provides the body position without forcing me to copy its identity, outfit, or background.

A prompt can be as direct as this:

Prompt: Keep the identity, hairstyle, facial features, and outfit of the character in @image1. Place the character in the pose shown in @image2. Use @image2 only as a pose reference and do not copy its appearance or background.

For difficult camera angles, I would add the framing and perspective in text, such as “full-body low-angle shot” or “side profile from waist level.” A pose reference gives the model the physical arrangement, while the prompt clears up anything the image leaves uncertain.

This is useful for action scenes, character sheets, thumbnails, and manga panels. It also reduces the need to describe every arm and leg position through a long prompt, which can become confusing once the pose gets complicated.

Turning a 2D Character Into a Figure

Character references can also change the presentation format. In the example below, PixAI turned a flat anime character into a PVC figure-style render while retaining the original design.

This is the prompt used for the example above:

Prompt: “Generate a PVC figure of this @image1 character, Glossy painted plastic surface with smooth highlights”

This does not create a printable 3D model file by itself. It creates a visual concept of how the character could look as a physical figure. An artist or 3D modeller could then use the result as reference when preparing the actual geometry, materials, pose, and display base for printing.

Where OC and VTuber Creators Can Use This

For original character and VTuber projects, one finished portrait is rarely enough. A usable character library may need front, side, and back views, several facial expressions, alternate outfits, promotional illustrations, reaction images, thumbnails, and scenes involving other characters.

Reference generation gives creators a faster way to expand that library. An OC character generator can take an approved design and explore how the character looks in a café, on a stage, during a fight scene, or in a different season.

VTuber creators can use the same process to plan costumes, expression sheets, stream graphics, and merchandise concepts before commissioning or drawing the final assets.

I would not rely on one front-facing portrait for every possible angle. The model cannot reliably infer details that were never visible, such as the back of a jacket or the exact structure of a hairstyle from behind.

For a long-running project, I would gradually build a small set of approved references from several angles.

PixAI’s OC and VTuber character guide also recommends combining reference images with stable prompts and, when stronger long-term consistency is needed, a trained character LoRA.

There are a lot more things you can do with PixAI’s new image editor plus its brand new image model, Tsubaki.3. I encourage you to explore the various use cases that you can do with it.

Tsubaki.3 Showcase | PixAI
See what Tsubaki.3 can do across nine capabilities - coloring breakdowns, character consistency, lighting, manga…pixai.art

Final Thoughts

So there you have it, you just read how Tsubaki.3 gave me a practical way to generate the same character in different scenes without training a custom model first.

As you’ve seen in the examples, I could transfer an outfit, replace one person inside a two-character composition, use a separate pose reference, and reinterpret a 2D design as a figure while keeping the subject recognizable.

A huge props to platforms like PixAI for giving anime creators access to models developed around their actual workflows. Character consistency is needed for comics, VTuber assets, visual novels, game concepts, and any project that uses the same cast more than once. Tsubaki.3 makes those experiments easier to start, even for someone who has not trained a LoRA or used a traditional image editor.

Tsubaki.3 remains in early access, but the official showcase already includes more examples involving character references, outfits, poses, manga, expression sheets, and multi-character scenes.

Check out PixAI and let me know what you think!

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Generating an AI image is one thing. Editing it with precision while keeping the character, composition, and art style consistent is much harder.

I have tried several AI-powered image editors, and many of them struggle with what should be a small change. I ask to replace an outfit or adjust a character’s pose, and it’s not uncommon to get a different face, altered proportions, or a background that no longer resembles the original. The requested edit happens, but everything around it changes too.

One that I often recommend is Midjourney’s image editor. It provides manual selection tools for choosing the area I want to modify, including brushes, shapes, and a lasso. However, I am still limited to Midjourney’s proprietary models, which are not specifically designed around anime illustrations.

Subscribe now

While looking for a more suitable AI anime image editor, I came across PixAI. The platform recently opened Creator Early Access for Tsubaki.3, the latest version of its anime-focused image model. It has better reference-image support, natural-language editing, more control over composition, and better preservation of character details.

In this guide, I will show how I used Tsubaki.3 to change poses, modify character details, add text, and color an unfinished sketch. I will also explain where the model did well and where I think it could still improve.

Let’s get started.

What’s New in Tsubaki 3?

Tsubaki.3 is the successor to Tsubaki.2, but PixAI is positioning it as more than another image-generation upgrade.

The model is designed to support more of the actual creative process, from early sketches and pose references to character sheets, manga panels, and finished illustrations.

PixAI says a single reference image can be enough for Tsubaki.3 to identify a character’s important visual traits and place that character in a new scene. Those traits can include the face, hair, clothing, accessories, and broader art style. It can also use reference images for objects and environments, rather than treating every upload as a character reference.

Here are some of its key features:

• Pose and action editing: Use a sketch, mannequin, or existing image as a pose reference while carrying over the appearance of another character.

• Add, remove, and replace objects: Insert new elements, remove unwanted details, or change an existing object through a written instruction.

• Add, remove, and replace text: Rewrite signs, remove existing lettering, or add text such as titles and speech bubbles.

• Color and background modification: Color unfinished line art, change the palette, or move a character into a different environment.

• Composite editing: Combine a character, outfit, pose, or setting from multiple uploaded references.

• Inpainting: Regenerate a specific part of an image to repair anatomy, clothing, faces, props, and other local details.

Tsubaki.3 also introduces a more controlled Color Palette system. Creators can choose a preset, enter hex codes, change the proportion assigned to each color, or extract a palette from an uploaded image. The character, background, and overall scene can each receive separate color instructions.

Feature descriptions only tell part of the story, so I tested several of these workflows using actual reference images.

Pose and action editing

I started with pose editing because this is where many general-purpose image models lose character consistency. The AI might understand the new position, but it often redraws the face, changes the outfit, or drops smaller accessories.

For this test, I uploaded one image containing the character I wanted to preserve and another image showing the target pose and composition.

Here are the input images:

Upload the images into the prompt field, set the aspect ratio and number of output images, select Tsubaki.3 in the model list, and enter the sample prompt below.

Prompt: Masterpiece, high-quality 2D anime illustration, vertical full-body, extreme low-angle shot, wide-angle perspective. A cute anime cat-girl stands slightly below center, taking a slight step and looking back, holding a large open umbrella that dominates the upper frame. She has short white hair with purple-blue gradient tips, heart-shaped ahoge, purple eyes, white cat ears, and a white tail with a dark blue ribbon. She wears a blue-and-white navy crop top, dark blue chest bow, purple heart ornament, white shorts, black Mary Janes, white socks, white bow-gloves, black choker, and small dark blue hat. Background: Narrow city alleyway enclosed by tall buildings, dense overhead power cables. Street cluttered with bright red traffic lights, STOP signs, barricades, and cones. Cloudy post-rain atmosphere, wet reflective ground. Cool grayish-blue palette with striking red accents.

The output followed the low-angle perspective of the pose reference while keeping the cat-girl recognizable. Her white hair, purple accents, ears, tail, outfit, and umbrella all remained part of the design.

Tsubaki.3 also understood the wider composition, including the oversized umbrella and the character’s position near the lower part of the frame.

The prompt is detailed because I wanted control over the final environment, clothing, camera angle, and color palette. For simpler edits, the instruction can be much shorter. A useful approach is to name the visual traits that cannot change, then describe the new pose and scene.

This workflow is not limited to sketches. I can also upload a photo of a person, a 3D mannequin, or an existing illustration and use its body position as the pose reference. That makes it useful for artists who already have a specific composition in mind but do not want to draw the pose from scratch.

Add, remove, and replace objects

Tsubaki.3 can also make smaller edits without rebuilding the entire image. I can upload an illustration, select the model, and describe the exact detail I want to change.

Here’s how it works: You upload an image, set the model to Tsubaki.3, and describe what you want to do in the prompt field.

Prompt: Change the character’s hair color from white to pale blue.

Here is a side-by-side comparison of the original image and the edited result:

I like how restrained the edit is. The model changed the hair from white to pale blue while preserving the face, expression, pose, outfit, accessories, lighting, and background. Even the shading within the hair was carried over instead of being replaced with a flat block of color.

The result was close to what I had imagined, and I did not have to paint over the hair manually or draw a selection around it. All I needed was a direct text instruction.

The same method can be used to replace clothing, remove an unwanted prop, add an accessory, or swap one object for another. More complicated edits still benefit from a precise description. If a scene contains several similar objects, I would specify their location, color, and relationship to the character so the model knows which one to change.

Add, remove, and replace text

Text remains one of the more unreliable parts of AI image generation. Models may misspell words, duplicate letters, or create something that resembles writing without being readable. This becomes a problem when creating manga panels, posters, book covers, character cards, or promotional artwork.

Tsubaki.3 can add new text as part of an edit, as well as remove or rewrite lettering that is already in an image. The workflow is the same as the previous examples. I uploaded the original illustration and described the text, placement, and surrounding elements.

Prompt: Add a speech bubble at the upper left of the character in this image, with the text “Thing’s are about to be better with Tsubaki.3!” inside it.

Perfect. The model placed the speech bubble near the character’s head without covering her face or important parts of the composition. It also selected a readable font size and fitted the sentence inside the available space.

I would still proofread every result before using it in a finished manga or poster. Longer sentences, decorative fonts, and unusually shaped text boxes give an image model more opportunities to make mistakes.

For short dialogue and simple labels, however, Tsubaki.3 can reduce the amount of manual layout work required after generation.

Color and background modification

Another practical use for Tsubaki.3 is turning an unfinished sketch into a colored illustration. This could help during the early stages of a drawing when I want to compare palettes, lighting, or environmental ideas before committing to one direction.

For the next example, I uploaded a bare sketch and asked the model to color it. Check this out:

Tsubaki.3 did more than place colors underneath the line art. It interpreted the character’s clothing and surrounding elements, added shadows and highlights, and produced a palette that felt consistent across the image.

The structure of the original drawing remained visible rather than being replaced with an unrelated character.

I can see digital artists using this for rapid visual development. An artist could test several palettes from the same drawing, compare daytime and nighttime lighting, or preview how a character might look against different backgrounds.

The background-changing workflow is similar. I can ask the model to move a character from a plain studio backdrop to a classroom, city street, forest, or science-fiction environment.

Why Should You Care?

AI image editing is incredibly useful when it removes repetitive work without taking control away from the creator.

Changing a hair color should not require regenerating a character twenty times. Testing a pose should not mean rebuilding an entire illustration from the beginning.

For independent artists and character designers, Tsubaki.3 can speed up experimentation. One character reference can be reused across new poses, expressions, outfits, and environments.

Manga creators can test panel layouts or speech bubbles, while animators can use the model to explore compositions before preparing finished frames.

Regular users do not need drawing or Photoshop experience to edit anime images with AI. A descriptive sentence can handle many changes that would otherwise require masking, layers, color correction, and manual repainting. People can modify profile pictures, create alternate outfits for original characters, or turn a sketch into something closer to a finished illustration.

There are still reasons to keep traditional editing tools. AI output is not deterministic, and a request can occasionally modify details that were supposed to remain untouched.

Fine typography, exact brand colors, and production-ready line work may still need manual correction. I see Tsubaki.3 as a faster way to reach a strong draft, followed by human review when precision is important.

Final Thoughts

Alright, that’s about it. In this article, Tsubaki.3 handled the four workflows I tested better than I expected.

It transferred a pose from one reference to another character, changed a local detail without redrawing the scene, added readable text, and converted an unfinished sketch into a colored illustration.

My favorite part is the amount of control available through ordinary language. I did not have to prepare masks or carefully trace every area I wanted to change.

I would still like more predictable control over how strongly an edit affects the source image, along with a clearer preview of which region the model intends to modify. Text rendering also needs to remain reliable across longer dialogue and smaller lettering.

I appreciate platforms like PixAI for investing in models made specifically for anime creators. General image models can produce anime artwork, but editing it consistently requires better knowledge of line work, character proportions, costume details, manga layouts, and the visual conventions behind the style. Tsubaki.3 feels much closer to a model developed around those needs.

Tsubaki.3 is currently available through PixAI’s Creator Early Access program, with a wider release planned after testing. Check out the official Tsubaki.3 showcase to see more examples, and let me know which editing workflow you would use first.

Let me know what you think!

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

If you build agents for a living, you probably noticed two things this year. Frontier closed models keep getting better on paper. At the same time, more developers say the models they pay for feel worse in day-to-day use, while a smaller open model handles the boring 80% of their workload just fine.

Subscribe now

So, how close are open-source models to GPT-class performance? Pretty close, although the answer depends heavily on the task. On broad reasoning and coding benchmarks, the distance is now only a few points. The proprietary frontier still wins on the hardest problems, multimodal breadth, and long-running agent tasks.

What “GPT-5-Class” Means in 2026

“GPT-5-class” is a moving target. GPT-5 launched on August 7, 2025. Since then, OpenAI alone has shipped 5.1, 5.2, 5.4, 5.5, codenamed “Spud,” in April 2026, and 5.6.

On Artificial Analysis, the original GPT-5 (high) is now marked deprecated and scores below the current median. The model did not get worse. The benchmark became harder, and the rest of the field moved ahead.

When someone asks whether open models have “caught GPT-5,” a better question is whether they have caught the current top proprietary reasoning tier. That tier now consists of a small group of models rather than one GPT version. Keep this in mind whenever a release claims to beat a specific model because the comparison may already be stale by the next quarter.

How Big Is the Gap?

Every lab reports the benchmarks where its models perform best, so measuring the gap gets messy. One reasonable approach is to use a neutral composite index.

The Artificial Analysis Intelligence Index combines nine difficult evaluations, including Humanity’s Last Exam (HLE), GPQA Diamond, Terminal-Bench, and long-context reasoning.

The best open-weight models trail the leading proprietary model by about six points. That sounds close, but the average hides some large differences between tasks.

⚠️ One caution before trusting any single number: Most open-model benchmark results are vendor-reported rather than independently verified, according to an August 2026 analysis from Morph. None of the SWE-bench Verified entries it tracked at the time were listed as independently verified. Treat “we beat GPT-5.x” claims in release announcements as something to test on your own data, not as a concrete fact.

Where Open Models Already Win

The retrieval layer and other narrow tasks are the easiest parts of an agent stack to move away from expensive frontier APIs.

Embeddings and reranking are the clearest examples. The Qwen3 embedding family shipped under Apache 2.0 with a 32,768-token context window, and its 8B model entered the MTEB multilingual leaderboard at number one.

Qwen3-Embedding-0.6B costs about $0.011 per million tokens to serve, which is tiny compared with many hosted alternatives. For retrieval-augmented generation (RAG), self-hosting the retrieval layer is already a practical option rather than an experiment.

Generation for narrow tasks is another good case. Alibaba’s Qwen3.8–27B, also released under Apache 2.0, scores 52 on the Artificial Analysis Intelligence Index. It quantizes to roughly 14 to 17 GB and can run on a single 24 GB GPU.

That is enough for classification, extraction, routing, and routine drafting without paying a per-token API bill for every request.

When the frontier is still the better choice: Use the frontier model when a task needs the best available reasoning and open alternatives fail your evaluation. Saving money on inference does not help if task success drops enough to create more work elsewhere. Measure the results first. Superlinked’s guide to what small open-source models can handle is a useful starting point.

Free to Download Is Not Free to Run

The open models competing near the frontier are enormous. Their weights may be free to download, but the GPUs are definitely not. We wish.

Many of the leading open models are mixture-of-experts (MoE) systems, and their weights still need to sit in GPU memory. Running the largest ones requires a cluster, not a gaming laptop.

These are approximate 4-bit footprints based on public deployment notes. You also need headroom for the KV cache, which grows with context length. The Kimi K3 estimate comes from a 2026 self-hosting cost breakdown.

The real comparison is not a free open model versus an expensive API. It is a per-token API bill versus GPU costs plus the engineering and operational work required to keep inference running.

Whether self-hosting makes financial sense mostly comes down to utilization. A GPU sitting idle is expensive hardware doing nothing. Superlinked’s analysis of whether you should self-host inference is a good starting point for working through that decision.

Route by Task, Not by Model

A production agent may perform several different jobs in one run:

• Embed a query

• Retrieve and rerank documents

• Extract fields

• Draft a response

• Handle the occasional difficult reasoning step

These jobs have very different capability requirements. Sending every step through one frontier API creates a large bill for work that a much smaller model could handle.

A more practical setup is to route each task to the right model.

This keeps high-volume routine work on cheaper infrastructure while saving frontier tokens for the steps where the stronger model changes the outcome. Superlinked’s practical guide to choosing models for agents goes deeper into this type of routing setup.

YOLOing It Yourself

Let’s say you have completed the evaluation and found that open models clear the bar for retrieval, extraction, and routine generation. The next problem is running all those encoders, rerankers, extractors, and generators without maintaining a separate serving setup for each one.

That is what SIE, the Superlinked Inference Engine, is designed to handle. SIE is an open-source inference engine that provides one endpoint for more than 100 open models covering embeddings, sparse retrieval, reranking, extraction, OCR, and text generation. It can run on your own hardware or through Superlinked Cloud.

There are two things SIE does not do:

• It does not make an open model smarter. SIE serves the model you choose, but it does not close the capability gap measured in this article. If a task needs a frontier model, SIE will not change that.

• It is not automatically cheaper. When traffic is low or inconsistent, a hosted API may still cost less. SIE makes more financial sense when the GPUs stay busy.

If that sounds close to your setup, the quickstart is the fastest way to test it. The SIE versus OpenAI breakdown also explains the hybrid approach: self-host the routine work and keep a frontier API available for the hardest 10%.

FAQs

Have open-source models caught GPT-5-class performance?

They are close on broad tasks, including general coding and reasoning. A noticeable gap remains on the hardest reasoning problems, long-running agents, and multimodal work.

What is the best open-source model in 2026?

There is no single best model. Kimi K3, GLM-5.3, and Qwen3.8 lead the neutral index used in this article, but the right choice depends on the task, available hardware, and license requirements.

Can I run a GPT-5-class open model on my own machine?

Some capable smaller models can run locally. Qwen3.8–27B and gpt-oss-20b, for example, can be hosted on a single GPU with enough memory. The largest frontier-level open models still require multi-GPU servers or full clusters.

Is self-hosting open models cheaper than using a hosted API?

Only when utilization is high and sustained. At lower usage levels, hosted APIs are often cheaper once GPU rental, engineering work, and ongoing operations are included.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

One of the coolest use cases I’ve seen for image models is generating manga pages. A single prompt can now produce the characters, setting, camera angles, speech bubbles, and even the dialogue inside them.

Sure, general-purpose AI apps such as ChatGPT and Gemini can create this type of content. However, I often notice the same strange anime aesthetic, inconsistent characters, and limited control over how each manga panel is composed.

Text rendering is another problem. Dialogue is sometimes misspelled, placed inside the wrong bubble, or has inconsistent font size/style.

A dedicated AI manga generator gives creators much more control.

Subscribe now

PixAI’s Tsubaki.3 model supports manga panelling, in-image typography, character references, and complex scenes involving multiple characters. It can also use an existing page as a structural reference instead of inventing a new layout for every generation.

So, if you are interested in creating your own manga pages or even turning them into full storybooks, I’ve got you.

In this guide, I will show you how to create manga pages using only text prompts, character images, and panel templates.

Let’s get started.

Here’s How It Works

Head over to PixAI and create an account. Open the image generator, upload a sample character image, and write a prompt describing the page you want to produce.

This is the prompt I used for my first test:

Prompt: Japanese black-and-white manga style, single-page four-panel layout with irregular panels, ink lines, halftone shading, solid black areas, speed lines, and sound effects. Preserve the reference character’s exact appearance, including her double buns, thin braids, colorful hair clips, large eyes, cropped top, striped arm warmers, loose shorts, glasses, shoulder bag, chains, and plush charm. Near a city station at dusk, Panel 1 is a vertical upper-left panel showing her bending toward a vending machine after her drink gets stuck, pointing at it with a confused expression and saying, “Wait… I pressed it properly. Why isn’t it coming out?” Panel 2 is a small upper-right close-up showing her crouching and peering into the dispensing slot, her face nearly touching the machine, saying, “I can see it in there…”

I also adjusted a few generation parameters. I selected Tsubaki.3 as the image model, set the aspect ratio to 3:4, chose high image quality, and generated one image.

A portrait ratio works well for manga pages because it gives the model enough vertical space to separate the panels without making every scene feel cramped.

I intentionally used a reference image that did not completely match the character description in the prompt. I wanted to see whether the model could combine the person in the reference with the clothing and hairstyle requested through text.

The output followed both sources surprisingly well. The subject still looked like the character in the uploaded image, but the model changed her hair, outfit, and accessories according to the prompt.

Tsubaki.3 can use up to three character references, and those references may come from previous PixAI generations or uploaded images. The model also supports instruction-based editing, so an incorrect outfit, expression, or text element can be changed without rebuilding the entire image from the beginning.

Let’s do another one without an input image.

Prompt: Black-and-white four-panel manga featuring the girl from image 1 after a long summer walk, preserving her twin braids, flower accessories, soft eyes, and summer outfit. Use a wide top panel, two smaller middle panels, and a wide bottom panel with white margins and narrow gutters. The top shows her beside a glowing vending machine on a quiet coastal road, studying the drinks while fanning herself. The middle-left shows her finger hesitating between 「ラムネ」 and 「冷たいお茶」, while the middle-right shows her making an overly serious face and saying 「……どっちにしよう。」 The final panel shows her smiling on a roadside bench with a cold, sparkling ramune bottle against her cheek. Add 「ブーン…」 for the machine hum, 「ピッ」 for the button press, and 「ゴトン」 for the falling bottle.

I love how consistent the character looks across the page. Her hairstyle, facial features, and outfit remain recognizable, while her expression changes naturally as the small story develops.

The changes in framing also help. The wide establishing shot introduces the location, the close-up shows her choice, and the final panel resolves the scene. These camera changes make the page feel illustrated by someone who understands manga composition rather than an image model repeating the same portrait four times.

The Japanese characters are clear and readable too. Aside from the speech bubble, the added sound effects give the panels more energy. 「ピッ」 and 「ゴトン」 describe actions that would otherwise need another sentence of narration, which is exactly how good manga lettering should work.

Manga, Webtoon, and Anime Screenshot Styles

The same workflow is not limited to traditional black-and-white pages. Changing a few visual instructions can turn the generation into a colored Webtoon episode or an anime screenshot.

• Manga: Ask for monochrome ink, screentone shading, white gutters, speed lines, high-contrast shadows, and Japanese sound effects.

• Webtoon: Use full color, clean digital line art, soft shading, vertical storytelling, wider spacing between scenes, and dialogue bubbles designed for mobile reading.

• Anime screenshot: Choose a 16:9 ratio and request cel shading, cinematic framing, background lighting, and subtitle-style text along the bottom instead of manga speech bubbles.

I would avoid combining all three styles in one prompt. A clear visual direction gives the model fewer conflicting decisions to make and usually produces a more coherent image.

Pages Matching a Reference Panel Layout

PixAI can also follow a reference panel layout. This is useful when I already have a page template or rough storyboard and want the AI to fill its empty spaces with finished scenes.

Instead of describing every panel’s dimensions, I can upload the template as the first reference. Additional images can then define the characters appearing on the page. PixAI’s own Tsubaki.3 showcase demonstrates this workflow using one layout reference and separate character images.

Here is what the image generator dashboard should look like:

These are the three input images. The first controls the page structure, while the other two introduce the characters:

Prompt: Japanese black-and-white manga style, single-page four-panel comic using the exact panel layout from reference image 1. Use the two characters from reference images 2 and 3 without changing their appearance or clothing. The black-haired character is casual, quick-moving, and slightly careless, while the blond character is calm, gentle, and mildly exasperated. Set the light, humorous scene along an outdoor walkway near a university building. In the large top establishing panel, show them walking side by side in a medium full-body shot. The black-haired character looks at his phone while carrying coffee and speaking casually, while the blond character holds several books and quietly looks toward him. Include simplified campus buildings in the background. Black-haired character’s dialogue: 「このあと時間ある？ 駅前に新しいカフェできたらしいし、ちょっと寄ってみない？」

The resulting page stayed close to the reference structure, and the scenes inside the frames followed the prompt. More importantly, the model understood that the references had different jobs. One supplied the composition, while the other two supplied character identities.

I also like how the speech bubbles float over the frames rather than being squeezed inside them. The AI manga panel generator had limited room for two characters, books, coffee, a phone, background architecture, and a fairly long line of Japanese dialogue, yet the page still remained easy to follow.

I can prepare layouts in advance, reuse the same character references, and change only the scene instructions and dialogue. That creates a repeatable workflow for producing a short chapter instead of treating every page as an unrelated image.

Who Can Benefit from this Tool?

An AI comic generator will not replace every part of drawing and editing a manga, but it can shorten several early stages of production.

It is especially useful when the goal is to explore an idea, test a sequence, or create a readable draft without illustrating every frame manually.

• Manga artists and writers can turn scripts and rough layouts into visual storyboards. This makes it easier to test pacing, camera angles, dialogue length, and panel order before producing final artwork.

• Original character and VTuber creators can place an existing character in short stories, reaction comics, promotional scenes, and alternate settings while preserving recognizable features across the page.

• Webtoon creators, video teams, and social media publishers can develop vertical comics, anime-style storyboards, short episodic posts, and visual scenes that may later be animated or edited into videos.

The reference workflow also helps people who are stronger at writing than drawing. A creator can begin with dialogue and a rough page template, then let Tsubaki.3 handle the first visual version.

I would still recommend using original or properly licensed character references, especially when the finished images will be published or used commercially.

Final Thoughts

Alright, I just showed you that the process of creating a manga page with AI involves more than asking for a black-and-white anime image. In these tests, I used character references, structured panel descriptions, direct dialogue, Japanese sound effects, and a reference layout to control how the story appeared on the page.

As you’ve seen, the model could manage both individual illustrations and multi-character sequences.

My favorite use case is reference-based page generation. It gives writers and artists a practical way to turn rough storyboards into complete scenes while keeping the characters and panel hierarchy consistent. Tsubaki.3 handled this particularly well, especially when moving between close-ups, full-body shots, expressions, and longer dialogue.

I also want to thank PixAI for releasing a refreshed image generator alongside Tsubaki.3. PixAI rebuilt its generation panel for the new model, while its larger model library gives creators plenty of room to experiment with different manga, Webtoon, and anime styles.

What do you think about using AI to create manga panels? Would you use it for finished pages, early storyboards, or simply bringing an original character into a short story? Let me know in the comments.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Yes, these models aren’t gonna replace a real human film crew anytime soon. They aren’t perfect, but they are already good enough for someone with a laptop and an internet connection to make a short drama.

The problems usually appear after the first clip. Mina may look great in the opening scene, then suddenly have a different face, jacket, and hairstyle five seconds later. The station can also change completely between camera angles. Put six or seven clips together, and those small differences become painfully obvious.

Subscribe now

I wanted to try Artlist here because most of the pieces are under one account. The AI Toolkit handles the images, video, voices, and music. Artlist Studio is where I can put the film together.

For this guide, I’ll use both tools to make a fictional vertical microdrama called The Last Platform. The images and reactions are placeholders for now. I’ll replace them once I generate the real assets.

Let’s get started.

What Is Artlist?

I originally knew Artlist as a stock music site. The company started as a music-licensing platform in 2016, then added sound effects, footage, templates, LUTs, and other assets used in video production.

It looks very different now. The AI Toolkit includes image, video, music, and voice generation, while Artlist Studio is made for longer projects with several connected shots.

There are also AI Apps for quick effects and Flows for building reusable generation chains.

Artlist also keeps its model catalog updated with the latest releases. At the time of writing, that includes newer models such as Seedance 2.5, Kling 3.0, GPT Image 2, and Nano Banana 2. New model updates are added directly to the Toolkit, so you do not need a separate subscription every time another company releases something I want to try.

Obviously, I’m not gonna use a hundred models to make one tiny film. I just want the freedom to use GPT Image for a character, Seedance for one scene, and perhaps Kling for another.

Start With the Story, Not the Video Model

Before I begin using the image generator, I need to know what actually happens in the story. Skipping to pour in time and effort into writing a good story is one of the biggest mistakes creators make.

So I’d write the plot first, followed by the characters, scenes, dialogue, ending, and a few visual notes. I should be able to explain the whole thing in one sentence. For a short piece like this, two characters and one main location are plenty.

Adding another character on the fly sounds easy, but it’s actually not. You’d need to make a new portrait, view it from several angles, create a voice, and match shots for that person. The same problem comes with every new location. I’d rather spend the time improving two characters people might remember.

I’m using 16:9 because this microdrama is meant for YouTube.

The Sample Microdrama

The Last Platform is a 75-to-90-second science-fiction drama set inside an almost empty metro station at midnight. Mina, a bicycle courier, finds an injured transit engineer named Elias waiting beside the last train. He shows her a photograph taken the following morning. It shows the station destroyed and Mina standing in the wreckage.

Elias tells her not to board. Mina assumes the photograph is a trick until she notices the silver hair clip she is wearing in the image. The train doors open, an announcement calls her name, and she has seconds to decide whether to trust him. She steps away just before the train leaves, and every light in the tunnel goes dark.

This gives me enough material to test Artlist without turning the article into a full movie production. There are two characters, a station and train carriage, plus the photograph and pocket watch. Rain, reflections, moving doors, and the final blackout should keep the visuals from getting boring.

My rough shot plan would look like this:

1. Establish the rain-soaked platform and Mina arriving with her courier bag.

2. Reveal Elias sitting near the final carriage with an injured forehead.

3. Show their conversation and the photograph passing between them.

4. Cut to Mina’s close-up as she recognizes her hair clip in the photograph.

5. Open the train doors while the station announcement calls Mina by name.

6. Let the train leave without her, followed by the tunnel blackout.

For the demo that I’m gonna share in this post, I’m stopping at six shots. Alright, now it’s time to get to work.

Use the AI Toolkit to Prepare the Assets

I’d start in the AI Toolkit and prepare the assets I know the story needs: Mina, Elias, the station, the train interior, the photograph, and a brass transit watch. I’d also make a few rough storyboard images before spending more credits on video.

The prompt box changes depending on what I’m making. Choosing Image brings up the image models and their settings, while Video shows controls for duration, resolution, references, and audio. I do not have to dig through a giant settings panel every time I switch models.

I’d begin with one image showing the general look of the film. Think of it as a mood board squeezed into a single frame. I mainly want to settle the colors, lighting, and how futuristic the station should feel.

Prompt: A cinematic frame from a grounded near-future science-fiction drama. An almost empty underground metro platform at midnight, wet concrete floor reflecting pale teal fluorescent lights and a few warm amber service lamps. Light rain blows in from an open section near the tracks. Realistic production design, restrained color palette, subtle film grain, natural contrast, contemporary wardrobe, no cyberpunk signs, no fantasy technology, no text, no logo.

For this pass, I’d use GPT Image 2 or Nano Banana 2. GPT Image 2 is useful for detailed prompts and complicated compositions. Nano Banana 2 is faster when I need several related frames and want to feed the model more references.

Here’s the output:

Awesome! I love the ambiance of the scene. It’s a little too dark, but the story needs that kind of aura anyway, so I’ll stick with it. The details on the wet floor and the reflections coming from the lights make the station look super realistic.

Generate Mina and Elias

One thing to know about the Characters feature is that it needs a source image. I’ll generate a clean portrait, open it from My Library, and select Use as character. Artlist then saves the likeness for later generations.

Mina and Elias will appear as named references inside the prompt box, and supported models let me tag them with @. That saves me from pasting the same physical description into six prompts. From experience, a written description alone is nowhere near enough to keep a face consistent.

Portrait prompt for Mina

Prompt: A 28-year-old Southeast Asian woman with an athletic build, oval face, dark brown eyes, and shoulder-length black hair tied into a low practical ponytail. She wears a charcoal waterproof courier jacket with a muted red lining, a black cross-body delivery bag, and one distinctive silver crescent hair clip above her left temple. Calm but alert expression. Front-facing, chest-up, neutral gray studio background, soft even lighting, realistic skin texture, grounded cinematic realism, no text, no logo.

Portrait prompt for Elias

Prompt: A 34-year-old man with a lean build, tired hazel eyes, short wavy dark hair, and light stubble. He wears a navy transit maintenance jacket over a pale gray shirt, with a small stitched rail emblem and a worn brass pocket watch chain. A shallow bandage sits above his right eyebrow. Reserved, urgent expression. Front-facing, chest-up, neutral gray studio background, soft even lighting, realistic skin texture, grounded cinematic realism, no text, no logo.

I gave each character a detail that should remain visible in close-ups. Mina has the silver hair clip, while Elias has the bandage and watch chain. The model will probably move the clip to the wrong side at some point. I’ll regenerate that image because the clip is part of the reveal, not random decoration.

The saved portrait will be clear, front-facing, and honestly a bit boring. That gives Artlist a clean view of the face. The dramatic lighting can come later when I generate the actual scenes.

Now, create new characters from these portrait photos by going to the Characters tab. Make sure to set the correct gender and give it a proper name.

Alright, the characters are ready. It’s time to build the environment.

Build the Locations and Props

Next comes the station. I’d generate a wide view, a medium view beside the last carriage, a closer view of the train doors, and a reverse angle facing the tunnel. The style image stays attached as a reference so I’m not relying on the model to remember the colors from text.

Your image generator dashboard should look like this:

Here’s the prompt:

Prompt: The same underground metro platform from the visual reference, seen toward the final carriage. Wet gray concrete, pale teal overhead tubes, two warm amber service lamps, black tiled tunnel entrance, simple steel benches, restrained near-future production design. Empty except for small maintenance equipment near one column. Vertical 9:16 composition with open foreground space for two actors, grounded cinematic realism, no people, no readable signage, no logo.

Leaving it entirely to the video model would probably give Elias a blurry card with nonsense printed on it. The pocket watch gets a separate reference as well, since small objects often turn into mush once hands start moving.

Prompt for the prop:

Prompt: Close-up evidence photograph printed on slightly bent instant-film paper. The image shows the same metro platform after a destructive electrical accident at dawn, broken ceiling panels, smoke, emergency lights, and Mina standing safely near the edge of the frame. Her silver crescent hair clip is clearly visible. Realistic damaged photograph texture, held against a neutral dark surface, no caption, no watermark.

I’d save the main reference as a Style Kit too. A Style Kit can hold reference images, colors, and written instructions, then apply them to supported Toolkit and Studio generations. Mine would contain the teal, amber, charcoal, and muted-red palette with a short note asking for grounded near-future realism.

The Explore tab is useful on days when I have no clear direction. I can find an image with lighting or composition I like, inspect how it was made, and remix the prompt. I still need to make it fit the story instead of copying a random aesthetic because it looks cool.

Prepare Dialogue, Voice, and Music

I’d record myself reading the dialogue before generating any voices. The recording can sound terrible. I only need the timing, especially the pause after Elias gives his warning and the moment Mina looks down at the photograph.

Artlist has text-to-speech, speech-to-speech, and custom voices. Speech-to-speech makes the most sense here because I can keep my timing and change how the speaker sounds. Voice cloning is available too, although I need permission from whoever owns the voice.

The dialogue can remain short:

Elias: “If you board that train, the station does not make it to morning.”

Mina: “How do you know my name?”

Station announcement: “Passenger Mina Reyes, the final train is waiting.”

I do not want dramatic music blasting through the whole thing. A low electronic pulse, distant rail vibration, and a short rise when Mina sees the photograph should be enough. Any weak train sounds can be replaced with something from Artlist’s SFX catalog.

If you don’t want to bother doing all these recordings or audio generation with AI, you can actually just leave it to Seedance 2.5 to overlay the dialogue on the video. Let me show you later on.

Move the Project Into Artlist Studio

With the assets ready, I can open Studio and create a 16:9 project. Scenes sits on the left, while the timeline is on the right. I frame and generate a shot in Scenes, then add the version I want to the timeline.

This is what the project dashboard looks like:

I could also have created the characters, locations, and props directly in Studio. Its character and location tools can generate several angles, giving Artlist a front, side, back, and three-quarter view to work with.

I’ll use that option for Mina and Elias because one portrait feels a bit thin for characters appearing in almost every scene.

Frame Before Directing

I’d create a still frame before turning each scene into video. Studio has normal free-form prompting, but it can also split the prompt into subject, location, action, composition, style, and mood. There are separate controls for the shot type, angle, lighting, camera, and lens.

Breaking those controls out makes the prompt easier to read. I can work on Mina’s position and the camera angle without mixing in the dolly movement, dialogue, and sound at the same time.

Here’s an example generating the first frame of every scene. Make sure to tag the correct reference image in the prompt. Do this to all the scenes in your film.

Every Studio shot needs a start frame. The end frame is optional. I’d use both for something precise, such as the train doors closing, but Mina’s close-up probably only needs a strong start frame and a simple directing prompt.

For all six frames, I’m keeping the project in 9:16 and using the same teal-and-amber color palette. I’d also stick with the ARRI Alexa 35 and Cooke S4/i lens settings throughout the film. Changing cameras and lenses in every scene could make the shots look like they came from completely different productions.

I’ll save the station location as @undergroundmetroplatform so I can tag it alongside Mina and Elias.

Scene 1 frame prompt

Prompt: Wide establishing shot of @undergroundmetroplatform at midnight. @Mina has just reached the bottom of the station stairs, standing in the left third of the frame with her black courier bag across her body. She looks toward the far end of the platform, where a small figure is barely visible beside the final train carriage. Wet concrete reflects pale teal ceiling lights and two warm amber service lamps. Deep tunnel in the background, light rain blowing across the tracks, grounded near-future realism, natural body proportions, subtle film grain, no motion blur, no readable signs.

This frame introduces Mina, the station, and the distance between her and Elias. I want Elias to be visible, though still small enough that the next shot feels like a proper reveal.

Scene 2 frame prompt

Prompt: Medium shot of @Elias sitting on a steel bench at @undergroundmetroplatform beneath a warm amber service lamp. He leans slightly forward with a bent photograph held near his lap. His forehead bandage and brass watch chain are visible. @Mina’s shoulder and courier jacket appear softly out of focus along the right edge of the foreground. Elias is looking down at the photograph before raising his eyes toward her. The final train remains still behind him, restrained teal-and-amber lighting, shallow depth of field, natural expression, no motion blur.

I’m including a small part of Mina in the foreground so the scene feels like a conversation rather than another isolated portrait of Elias.

Scene 3 frame prompt

Prompt: Over-the-shoulder shot from behind @Mina at @undergroundmetroplatform. Her shoulder and low ponytail frame the left side of the image. @Elias sits opposite her, holding the bent photograph between his fingers near his chest, about to offer it to her. Both of their hands are clearly visible and separated. Focus on Elias and the photograph, with the train and station lights softly blurred in the background. Warm service light on Elias’s face, cool teal light around Mina, realistic hands, natural finger positions, no motion blur.

The hand placement needs to be clear here. I do not want the starting frame to show both characters already grabbing the photograph because that gives the video model too many fingers to sort out.

Scene 4 frame prompt

Prompt: Tight close-up of @Mina at @undergroundmetroplatform holding the bent photograph just below her face. She looks down at it with a skeptical, slightly confused expression. Her silver crescent hair clip is clearly visible above her left temple and matches the clip shown inside the photograph. Pale teal station light falls across one side of her face, while a soft amber reflection touches the other. Background heavily blurred, realistic skin texture, shallow depth of field, restrained emotion, no motion blur.

I’m starting Mina with a doubtful expression instead of full fear. The directing prompt can handle the small change in her face as she recognizes herself in the photograph.

Scene 5 frame prompt

Prompt: Medium profile shot of @Mina standing at @undergroundmetroplatform with the closed train doors directly behind her. She still holds the photograph in one hand and faces @Elias, who appears partly visible near the edge of the frame. Mina’s body is angled toward Elias, but her eyes have started to drift toward the train. The carriage interior behind the glass is dark and empty. Cool teal platform lighting, faint amber reflection on the wet floor, station speaker visible above the doors, natural posture, no motion blur, no readable text.

The doors are still closed in this frame. Their opening, the white light from the carriage, Mina turning around, and the station announcement all belong in the video prompt.

Scene 6 frame prompt

Prompt: Wide medium shot of @Mina and @Elias standing together at @undergroundmetroplatform in front of the open train doors. @Mina is closest to the carriage, with one foot near the entrance and the photograph still in her hand. @Elias stands slightly behind her, watching the empty train interior. Cold white light spills from the carriage onto both characters and across the wet platform. The tunnel beyond the train remains dark, teal and amber station lights still visible, tense but quiet composition, realistic proportions, no motion blur.

This frame picks up right after Mina turns toward the open carriage. From here, the directing prompt can make her step backward, close the doors, send the train into the tunnel, and finally shut off the lights.

I kept movement out of these prompts on purpose. The start frames only need to establish where everyone is standing, what they are holding, and how the shot is composed. The movement, dialogue, sound, and camera direction can stay in the six video prompts that follow.

Direct the Six Shots

These are still dummy prompts. Each one would have the correct Character, Location, and prop references attached, so I do not need to describe Mina’s face or the station all over again.

To start generating the videos per scene, switch to the Directing tab and make sure the starting frame for each scene is correctly set. Next, add your video prompt, submit, and wait for the scenes to be completed.

Here are all the prompts used for each scene in my demo:

Scene 1 prompt

@Mina enters the empty platform from the stairs and slows when she notices someone near the final carriage. Her wet courier jacket catches the overhead light. Begin with a wide establishing frame, then track backward as she approaches. Natural walking motion, restrained expression, rain ambience, distant electrical hum, no dialogue.

Here’s a 5-second sample video for this prompt:

Scene 2 prompt

@Elias sits on a steel bench beneath an amber service lamp, holding the old photograph. He looks up at @Mina but does not stand. Medium shot with a slow dolly in. His breathing is controlled but strained. He says quietly, “If you board that train, the station does not make it to morning.” Keep the background train still.

Scene 3 prompt

Over-the-shoulder shot from behind @Mina as @Elias extends the bent photograph toward her. She takes it without looking away from him. Focus shifts from his face to the photograph between their hands. Minimal body motion, realistic fingers, low station ambience, no camera shake.

Scene 4 prompt

Close-up of @Mina studying the photograph. Her suspicion changes to recognition when she sees the silver crescent hair clip in the image. Very slow push-in, shallow depth of field, no exaggerated fear, no dialogue. End with her eyes lifting toward @Elias.

Scene 5 prompt

The train doors slide open behind @Mina, filling the platform with cold white light. She turns halfway toward the empty carriage as the station speaker says, “Passenger Mina Reyes, the final train is waiting.” Medium profile shot, gentle handheld movement, realistic synchronized announcement, increasing electrical hum.

Scene 6 prompt

@Mina steps backward beside @Elias as the train doors close and the empty train accelerates into the tunnel. Track the departing train for a moment, then pan back to both characters. Every tunnel light turns off in rapid sequence toward the camera. End on darkness with the sound of the brass pocket watch stopping.

Once all the scenes are ready, open the Editor dashboard and export the final video. Here’s a snippet of the final result:

Pretty cool, right? I know this is only a snippet of the whole microdrama I am working on. But you can already see the potential here.

With regard to the quality of the video, things can be pushed even further. I’d start with Seedance 2.0 in Studio because the story is already broken into short shots and I want the higher-resolution output.

Seedance 2.5 would be tempting for a longer scene with native audio. It can run for up to 30 seconds and take as many as 50 image, video, and audio references, although the available resolution and Unlimited coverage depend on the mode and plan.

Continue Shots Instead of Starting Over

Studio also lets me pause a clip and carry one frame into the next shot. That should help around the photograph handoff and Mina turning toward the train. Her exact pose comes across with the frame, so I am not trying to describe the bend of an elbow or the position of a hand in text.

The usable clips go onto the Studio timeline, where I can reorder, trim, split, preview, and export them. That should be fine for a first cut.

I’ll probably finish the film in Premiere Pro or DaVinci Resolve because Studio is still pretty basic for sound mixing, captions, color correction, and exact timing.

What Else Should You Know About Artlist?

There are a few more Artlist features I would not ignore.

Flows is a node-based canvas that connects prompts, references, image generators, and video generators. For another film, I could connect a text prompt to an image model and feed the chosen storyboard frame into a video model.

Old results stay inside each node, which is handy when the newest generation somehow comes out worse than the first one.

AI Apps cover the quicker jobs. There are more than 70 for things like UGC product videos, camera moves, loops, product ads, and upscaling. They are mostly for familiar formats where I just want to upload something, choose a look, and get the result.

Video templates are a different thing. These are downloadable titles, transitions, and motion graphics for After Effects, Premiere Pro, Final Cut Pro, and DaVinci Resolve. They are not AI Apps and cannot be edited on the Artlist website.

The old Artlist catalog is still useful here. A stock train sound will probably be more reliable than whatever the video model creates, and a two-second city shot may already exist in the footage library. There is no prize for generating every single frame with AI.

There is a Premiere Pro plugin as well. It brings the Toolkit and Artlist library into the editor, which should cut down on some of the downloading and tab switching.

I also need to watch the credits. Toolkit and Studio draw from the same balance, with the cost changing based on the model, duration, resolution, and other settings. The Unlimited option only covers selected models and modes. Fair-use and parallel-generation limits still apply as well.

Most of the early experimentation can happen with cheaper image generations. I’ll save the more expensive video runs for the point where the faces, locations, and shot list are already settled. Otherwise, that monthly balance can disappear surprisingly fast.

Artlist says creators keep the rights to their own AI generations after the subscription ends, provided the work follows its terms. Stock files and assets downloaded from Explore follow different rules. I’d read the exact license before using those in client work because the difference is easy to miss.

Final Thoughts

Alright, that’s about it. I hope you enjoyed reading this little guide.

The whole process starts with the story. For this example, I wrote a small plot, broke it into six shots, created the characters and locations in the Toolkit, prepared the voices and sound, then moved everything into Studio. The genre can change, but I’d follow roughly the same order for another microdrama.

Personally, I like having the AI tools and stock catalog under one account. I can generate the characters, grab stock sound effects, make a voice, test a couple of video models, and assemble a first cut without moving files through five unrelated services.

I also have to give Artlist credit for making these tools available to people who are not filmmakers. Someone can mess around with a weird 20-second story just for fun, while a more experienced creator can bring a script, references, and proper editing into the same toolset. Not every generation will work, of course, but trying the idea is now much easier.

I’ll replace the placeholder images and reactions once I generate The Last Platform for real. In the meantime, what do you think about the tools covered in this guide?

Would you start with the Toolkit, build something in Flows, or jump straight into Studio? Let me know in the comments.

FAQs

What is the difference between Artlist AI Toolkit and Artlist Studio?

The AI Toolkit is mainly for generating individual images, videos, voices, and music. Artlist Studio is better suited for longer projects because it lets me build characters and locations, frame shots, direct scenes, and arrange the clips on a timeline.

Does Artlist have the latest AI models?

Yes. Artlist regularly adds newly released image, video, voice, and music models to its catalog. Current options include Seedance 2.5, Kling 3.0, GPT Image 2, Nano Banana 2, Veo, Sora, Lyria, ElevenLabs, and several Artlist models.

Can I create a complete microdrama inside Artlist?

Yes, especially for a short first cut. I can generate the characters, locations, voices, music, and individual scenes, then arrange and trim the clips inside Studio. I would still use Premiere Pro or DaVinci Resolve for more detailed sound mixing, subtitles, color correction, and exact timing.

Which Artlist video model should I use for a microdrama?

It depends on the scene. I’d use Seedance 2.0 for short, higher-resolution shots inside Studio. Seedance 2.5 is more useful for longer scenes with native audio and several image, video, or audio references. Since the models are available from the same Toolkit, I can also test Kling or Veo when a scene does not work well with Seedance.

Can I use Artlist’s AI-generated videos commercially?

Artlist says creators can use their generated outputs in commercial and client projects under its license terms. Generated outputs and stock assets are not handled exactly the same way, though, so I would still check the license attached to the subscription before publishing paid client or broadcast work.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

ByteDance released Seedance 2.5 at the end of July, while Alibaba introduced Wan 3.0 several weeks later. For someone looking for the best video model, choosing between them might come down to whichever output looks better.

But output quality is only one factor when choosing the right video model for a specific use case. Generation time affects how long users sit on a loading screen. API pricing determines how many videos can be included in a subscription.

Subscribe now

Resolution, reliability, reference limits, and editing features can also decide whether a model fits the intended workflow.

I tested Seedance 2.5, Wan 3.0, and the speed-optimized Wan 3.0 Prime under similar conditions on Topview. All videos were set to 15 seconds, 16:9, and 720p.

I then compared the visual quality, measured the generation time and credit use, and looked through their current feature sets.

Seedance 2.5 vs. Wan 3.0 at a Glance

Here is a summary of how their current APIs compare.

The specifications reveal how differently the models are positioned. Seedance 2.5 accepts far more reference material, while Wan 3.0 offers higher output resolution, a higher frame rate, more input types, and lower generation costs.

According to ByteDance’s Seedance 2.5 announcement, the model accepts up to 30 images, 10 videos, and 10 audio clips in one request. Its current BytePlus API generates 480p or 720p video at 24 frames per second.

Alibaba’s Wan 3.0 documentation lists 480p, 720p, and 1080p output at 30 frames per second. It accepts fewer media references, but it can also use supported documents and public webpages as source material.

How I Tested Both Models

I used text-to-video mode on Topview so neither model could rely on an image or video reference. Each video was configured to run for 15 seconds at 720p in a 16:9 aspect ratio, with native audio enabled.

Setting the parameters for Seedance 2.5 on Topview. Image by Jim Clyde Monge

I used the same prompt and settings for every model. For the quality comparison, I generated one Seedance 2.5 video and two Wan 3.0 videos. The second Wan output gave me a better idea of how much the results could vary between generations.

Comparison #1: Which Model Produces Better Video Quality?

I used a hand-to-hand combat scene for the first comparison. Fast movement involving two people is a difficult test because the model needs to preserve both characters, render physical contact, control the camera, and keep the motion believable.

Here is the prompt I used:

An action-film sequence inside a rain-soaked concrete parking garage at night. Two adult male stunt performers engage in fast hand-to-hand combat. The first man wears a black leather jacket over a red shirt. The second wears a gray hoodie and dark blue pants.

Seedance 2.5

I love the rain effect in the Seedance output. The water, reflections, lighting, and atmosphere make the parking garage feel much more realistic.

The camera work also adds a lot to the scene. It zooms in to focus on the characters’ facial expressions before pulling back when the fight begins. The movement feels intentional and helps establish the tension instead of immediately throwing both characters into random punches.

The fight itself is well composed, even though the model does not generate as many punches as Wan. The characters remain recognizable, their clothing stays consistent, and the wider camera framing makes it easier to follow their movements.

Wan 3.0

The first Wan output contains more punching, which makes the fight feel busier. However, the movements are slower than I expected from the prompt. The strikes lack speed and force, so the scene does not feel like a convincing high-intensity fight.

The background music is also distracting. It competes with the action rather than supporting it, and the environmental details do not have the same realism as the Seedance result. The parking garage looks more like a generated set than a real location.

Wan 3.0 Prime

The second Wan generation has much better background music and contains the most thrown punches among the three videos. It follows the combat part of the prompt more aggressively, and the fight has fewer inactive moments.

However, it still does not match Seedance in realism. The lighting, rain, character movement, and environmental details feel less convincing. One of the characters also appears to teleport during the final few seconds, which makes the ending look funny and strange.

The variation between the two Wan outputs is also noticeable. The second attempt improves the music and action, but the character error near the end introduces a new problem. More activity does not necessarily produce a better scene when the model cannot keep the subjects and their positions stable.

My winner for output quality is Seedance 2.5.

Wan generated more punches, but Seedance produced the more convincing action-film sequence. Its rain effects, camera composition, character consistency, and overall realism made the result feel closer to an actual movie scene.

Comparison #2: Generation Speed and Reliability

The next comparison measured how long each model took to generate a video. I used a rally car scene with fast movement, reflections, environmental effects, camera motion, and native sound.

Here is the prompt:

A tracking shot of a red rally car driving at high speed through a rain-soaked city at night. The camera follows close behind before moving alongside the vehicle. Water sprays from the tires, neon signs reflect across the wet road, and the car passes beneath three streetlights. Include realistic motion, engine audio, rain ambience, and tire sounds.

Seedance 2.5

Wan 3.0

Wan 3.0 Prime

I started timing after submitting each request and stopped when the completed video became available. All three models generated a 15-second, 720p video in a 16:9 aspect ratio.

Wan 3.0 was the fastest in this test. It finished in 58 seconds, while Seedance 2.5 needed 3 minutes and 15 seconds. Wan completed the job 2 minutes and 17 seconds earlier while consuming only one-third of the credits.

Wan 3.0 Prime produced an unexpected result. Alibaba positions Prime as the speed-optimized version, but it took 1 minute and 43 seconds in my test, which was 45 seconds slower than standard Wan 3.0. It also consumed 50% more credits.

One generation is not enough to conclude that Wan Standard is always faster than Prime. Queue traffic and available processing capacity can affect completion time. However, Prime did not provide a speed advantage in this particular run, despite its higher credit requirement.

The winner depends on the priority.

Seedance 2.5 took longer and used more credits, but it produced the better-looking combat video in the quality test. If visual realism is the priority and waiting several minutes is acceptable, Seedance remains a reasonable choice.

Comparison #3: How Much Does Each Model Cost?

The credit difference is already substantial.

On Topview, a 15-second Seedance 2.5 video consumed 22.5 credits. Standard Wan required 7.5 credits, while Wan Prime used 11.25.

This means standard Wan was three times cheaper than Seedance under the platform’s credit system. Prime was twice as cheap as Seedance but 50% more expensive than standard Wan.

BytePlus estimates Seedance 2.5 pricing using a base rate of $0.303 per second and a resolution multiplier. A 720p text-to-video generation without input video has a multiplier of 1.525, producing an estimated cost of approximately $0.462 per output second. A 15-second generation would therefore cost about $6.93.

Alibaba Cloud lists standard Wan 3.0 at $0.10 per second for 720p, making the equivalent 15-second generation $1.50 at list price. Wan 3.0 Prime costs $0.14 per second, or $2.10 for 15 seconds. Alibaba currently offers a temporary discount on standard Wan, but I would use the regular rate when calculating the long-term cost of a product.

At these rates, standard Wan costs less than one-quarter of Seedance for the same duration and resolution. That difference can affect subscription pricing, free trials, monthly credit allowances, and the number of retries an app can give its users.

The cheapest model is not automatically the least expensive in practice. If a lower-cost model requires several attempts before producing an acceptable video, the savings become smaller. Cost per usable output is more useful than cost per generation.

Comparison #4: Which Model Has the Stronger Capability Set?

Both models support text-to-video, image-to-video, first-and-last-frame control, multimodal references, native audio, video editing, and video extension. Their individual limits create different advantages.

• Wan 3.0 has better output specifications. Its API supports up to 1080p at 30 frames per second, while Seedance 2.5 currently reaches 720p at 24 frames per second through BytePlus. Wan can also generate clips from two to 30 seconds, while Seedance starts at four seconds.

• Seedance 2.5 provides more reference control. A single request can include up to 30 images, 10 videos, and 10 audio clips. This is useful for scenes involving multiple characters, outfits, products, locations, voices, and motion references. ByteDance also supports timestamp-based prompting, targeted edits, camera adjustments, green-screen replacement, and clay-render references.

• Wan 3.0 accepts a wider variety of sources. Along with images, videos, and audio, it can use supported documents and public webpages. It also provides standard and Prime variants, giving platforms another way to balance price and generation time.

Seedance has a better reference system and gives creators more control over complex scenes. Wan has better output specifications, broader source inputs, and more flexible pricing.

Where Does Wan 3.0 Have the Edge?

Wan 3.0’s strongest advantage is efficiency. It generated my 15-second test video in less than a minute and consumed one-third of the credits used by Seedance 2.5.

It also supports 1080p output, runs at 30 frames per second, accepts documents and webpages, and offers a separate Prime version. These advantages are useful for an AI video app where generation volume, waiting time, and cost can be just as important as getting the best-looking result from one prompt.

Its weakness in my testing was visual realism. Both Wan combat videos contained more punches, but Seedance handled the camera, rain, lighting, environment, and character consistency better. Wan still needs to close that quality gap before I would choose it purely for cinematic work.

Which AI Video Model Should You Choose?

I would choose Seedance 2.5 when visual realism and composition are the priorities. It was considerably slower and more expensive, but it produced the better action scene. Its larger reference limit also makes it a better fit for complex projects involving recurring characters, products, or locations.

Standard Wan 3.0 is a better pick for a high-volume video generator. It was the fastest and cheapest model in my test, and its API supports 1080p output. Do not overlook this model if you’re doing social videos, quick experiments, and products where users generate several variations.

Wan 3.0 Prime sits between them in price, but its role is less clear based on this single run. I would test it several more times before charging users extra for it. Standard Wan was both faster and cheaper based on the results.

So all in all, users who care about speed and credit use can choose Wan, while those working on cinematic or reference-heavy projects can spend more credits on Seedance.

Final Thoughts

Based on the comparison above, Seedance 2.5 is still my personal choice for video generation. Its combat scene looked more realistic, the rain and lighting were rendered better, and the camera moved with more intention. If I were choosing one output to keep, I would pick Seedance without hesitation.

However, Wan 3.0 has the better practical edge. It generated a 15-second video in only 58 seconds and consumed 7.5 credits, while Seedance took 3 minutes and 15 seconds and used 22.5 credits. Wan also supports 1080p output at 30 frames per second, accepts documents and webpages, and costs far less through the first-party API.

These are the advantages that some devs look for especially when used inside a web app. Faster and cheaper generations make it possible to offer more credits, support more retries, and serve more users without increasing subscription prices.

If I were adding both models to an AI video platform, Wan 3.0 would be the affordable default, while Seedance 2.5 would be the premium option for cinematic and reference-heavy projects.

What do you think of this comparison? Let me know if you find it useful.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Last week, CNN published a report about the explosive growth of AI-generated microdramas in China. More than 120,000 microdramas were released in the first three months of 2026, and around 95% of them were generated using AI.

A year or two ago, most AI video discussions were about whether a model could keep a character’s face consistent for ten seconds. Now entire production pipelines are being built around these models, and creators are publishing serialized stories at a volume that would have been impossible with traditional production.

I’m pretty sure anyone who spends enough time on TikTok, Instagram, or Facebook has already watched at least one of these AI dramas.

Some are obviously generated, especially when the motion gets complicated or objects start behaving strangely. Others are convincing enough that I sometimes only notice after a character changes slightly between cuts or a background detail suddenly disappears.

What’s even more interesting is how these productions are set up and how the final video series are actually being made.

There are currently a handful of video generation harnesses and web platforms that let you create full-length AI films with very little effort.

Subscribe now

For example, Topview’s Drama Studio and Film Studio are trying to organize the messy production work around the models, from story development and character creation to storyboarding, scene planning, generation, and editing.

For anyone curious about how these AI dramas are being produced, the process is a lot more structured than repeatedly typing prompts into a text-to-video box.

Go Short or Long Form AI Film

Topview currently offers two filmmaking products that serve different kinds of creators.

Drama Studio is designed for microdramas and episodic stories. I can start with an idea, outline, script, or longer piece of source material, then let AI agents help break it down into scenes, characters, environments, storyboards, and video.

This is what a sample video series built with Drama Studio looks like:

As you can see above, multiple scenes are getting stitched together to form a long and multi-scene video. The result is a few minutes of video clip that could be an episode of a series.

Here’s what the final video looks like:

Film Studio is for projects where I want much more control over the actual shot. It gives me tools for character performance, camera direction, scene composition, blocking, and visual refinement, which makes it closer to a filmmaking workspace than an automated series generator.

As you can see above, the dashboard gives you tons of freedom and control over each scene in the sci-fi film. You have a chat box on the right side, which lets you delegate any work to an AI agent instead of you manually doing all the work.

Here’s what the final video looks like:

Pretty cool, right?

Both Drama Studio and Film Studio are powered by Seedance 2.5 model, so you can expect high-quality and realistic video sequences every single time.

I would not overthink the choice between them. If the main problem is producing several connected episodes efficiently, Drama Studio makes more sense. If the project depends on precise framing, performances, or how one shot connects to another, Film Studio is the better fit.

I sometimes create short AI films just for fun and send them to my mom afterward. Most of them are little fantasy or science-fiction ideas that would never justify renting equipment, finding actors, or learning a complicated 3D animation pipeline.

Being able to make those scenes at home is fun on its own, but the same tools become much more interesting when I imagine what an independent filmmaker with a finished script could do with them.

Topview’s Drama Studio

I previously wrote a more detailed guide to Drama Studio, so I will keep the walkthrough shorter here. You can read it below.

The Fastest Way to Create an AI Series with a One-Person Drama Studio
You don’t need a crew, a camera, or a budget to make an episodic drama anymore. You need a story and an afternoon.generativeai.pub

The thing that you need to know about this tool is that it treats a drama as a production instead of a collection of separate generations. I give it a story, then the agent helps organize the pieces needed to turn that story into an episode or series.

Some of its key features include:

• AI-assisted script development for turning an idea, outline, script, or longer story into scenes and dialogue.

• Reusable characters, locations, and props that stay connected to the same project.

• Storyboard generation before committing to more expensive video renders.

• Shot-level editing and regeneration when only part of an episode needs to change.

• Multi-episode continuity for stories that reuse the same cast and environments.

When I tested Drama Studio earlier this year, I used it to create a fantasy confrontation between a human paladin and an orc warrior. The original idea was pretty simple, but the system helped expand it into something closer to an actual sequence by creating characters, establishing the environment, breaking the action into scenes, and preparing the visual direction for each shot.

Without a system like this, I would normally handle all of those steps manually. I would generate a character image, save it somewhere, create a second character, keep track of the references, write prompts for every new shot, and repeatedly remind the video model what everyone is supposed to look like. Once the story reaches several scenes, keeping all of that consistent becomes more annoying than writing the story itself.

Drama Studio keeps those assets attached to the same project, so I can reuse the characters and environments instead of rebuilding the context every time.

Here’s a sample project board I have with one of my mini film series.

The storyboard stage also gives me a cheap place to make mistakes. If the orc is standing on the wrong side of the frame or the paladin suddenly has different armor, I would rather notice that in a still image than after generating the final video.

This is why I think Drama Studio fits microdramas particularly well. Romance series, fantasy serials, short horror stories, anime-inspired episodes, or vertical dramas for mobile platforms all reuse characters and locations heavily.

Producing five or ten episodes a week is less about creating one spectacular shot and more about keeping the production moving without losing consistency.

I still would not publish everything the agent writes or generates without reviewing it. Dialogue usually benefits from a human rewrite, pacing needs judgment, and some scenes simply need several attempts before they work. But I would rather spend my time fixing those creative problems than manually rebuilding the same production setup for every episode.

Topview’s Film Studio

Film Studio goes further in the opposite direction. Instead of trying to automate as much as possible, it gives creators more control over what happens inside an individual shot.

That approach is closer to how I think serious AI filmmaking will develop.

Prompting works well when I am flexible about the result. If I write “a woman waits nervously in an empty train station,” a good video model can make something visually impressive from that sentence.

But filmmaking becomes more specific once I care about how nervous she looks, whether she avoids eye contact, where she stands relative to the camera, or how slowly the camera moves toward her.

Those details are difficult to control through text alone.

Film Studio introduces controls that separate some of those decisions from the prompt itself. Character expressions, camera placement, scene composition, and blocking can be treated more deliberately instead of being bundled into one paragraph of instructions and left to the model to interpret.

Here’s an example mini AI film I am currently working on.

As you can see, every character can be controlled by a series of instructions. You decide her story, her looks, her background, and personality.

This is a sample snippet of the mini AI film:

This information gives the AI agent an idea of how the character should look and express in every scene.

AI models can generate beautiful faces now, but subtle acting is still inconsistent. A character might react too strongly, smile at the wrong moment, or exaggerate an emotion that should have been barely visible.

Giving creators a visual way to adjust the emotional performance makes more sense than rewriting “slightly worried, but trying not to show it” five different ways and hoping the next generation gets closer.

The same applies to camera work. A camera angle is not just decoration. Moving closer to a character can make a conversation feel uncomfortable.

Shooting from behind someone can hide information. Keeping the camera wide for a few extra seconds can change the timing of a reveal. When these choices are left entirely to the model, the result might look cinematic without actually saying what I wanted the scene to say.

Film Studio also brings 3D scene blocking into the workflow, which is one of the more useful ideas I have seen in AI video tools.

See the sample workflow below and notice how the 3D scene helps with the blocking.

Traditional filmmakers and animators use blocking and previs to establish where actors, cameras, and objects are placed before the expensive production work begins.

Using the same concept for generative video gives the model better spatial guidance and gives me a way to inspect a scene before rendering it.

This solves a problem that shows up constantly in longer AI videos. A character may be standing on the left side of the room in one shot and somehow appear on the right in the next. Two people having a conversation might swap positions between cuts.

A door that was behind someone suddenly appears beside them. These mistakes are small individually, but enough of them can make a scene feel incoherent even when every frame looks good.

More controllable production tools also change the economics of experimentation. According to Caixin, some Chinese teams are already producing around 100 minutes of AI microdrama in only a few days for a fraction of the cost of traditional production.

I would not compare that directly with a major studio movie. A $150 million feature film involves actors, sets, physical effects, location work, stunt teams, production design, post-production, and a huge amount of coordination that current AI tools cannot simply replace.

The more realistic challenge comes from smaller productions.

An indie filmmaker who previously had enough money for a three-minute proof of concept may eventually be able to produce an entire pilot. A writer with an ambitious science-fiction script can visualize scenes before pitching it to investors. Small animation teams can test complete sequences instead of committing months of work to the first version.

But of course I am not here to spit all praises to AI. I am also aware of the existing limitations.

I see continuity errors, strange physics, inconsistent props, awkward facial animation, and plenty of clips that need to be regenerated. But the improvement has been fast enough that I would be careful about treating any current limitation as permanent.

Two years from now, the more important question may not be whether AI can generate a convincing film scene. It may be how much creative control platforms like Film Studio can give the person directing it.

Which Tool Should You Use?

Drama Studio and Film Studio overlap in some areas, but they are built around different production styles. Drama Studio is better when I want an AI agent to manage more of the repetitive work involved in making a series. Film Studio makes more sense when I want to spend more time directing individual scenes.

I would choose Drama Studio as a solo creator producing vertical drama series, a writer turning stories into episodes, a social media creator experimenting with serialized fiction, or a small team that needs to publish frequently without rebuilding the production setup every time.

I would choose Film Studio as an indie filmmaker, director, animator, cinematographer, or experienced AI video creator who wants to spend more time deciding how a scene should actually look and feel.

For a bigger project, I can also imagine using both.

Drama Studio could handle the recurring production work around the story, characters, and episodes, while the most important scenes could receive much more deliberate treatment using the controls available in Film Studio.

That combination is probably closer to how I would work. I like automation when it removes repetitive tasks, but I still want to make the decisions that define the final scene.

Topview’s Drama Studio and Film Studio show two directions AI filmmaking is moving at the same time. One uses agents to reduce the amount of production work required to turn a story into several episodes.

The other gives creators more control over the parts of filmmaking that are difficult to express through prompts alone, including performance, camera placement, blocking, and continuity.

AI Could Drastically Change How Films Are Produced

I do not think AI suddenly makes filmmaking easy. Writing a good story is still difficult, pacing still requires judgment, and giving an audience a reason to care about a character has very little to do with how photorealistic the generation model is.

Perhaps the biggest change is the cost and speed.

A specific movie scene that once required actors, costumes, a location, cameras, lights, and a crew can now be explored on a laptop before anyone spends money on physical production.

Did you know that the sinking ship scene in Titanic cost $141 million?

Yup, that’s the most expensive single scene or sequence in movie history.

Today, anyone can create a similar scene for less than a dollar in 2 minutes.

Over time, I think that will have a much larger impact than the novelty of AI-generated video itself.`

More People Can Now Attempt Projects That Used to Be Impractical

This is why I appreciate platforms like Topview putting these tools into products that people can actually use.

We already know modern video models can generate impressive images. The more difficult problem now is turning those images into stories that stay coherent for several minutes, several episodes, or eventually an entire movie.

Drama Studio is approaching that problem through agents and production automation. Film Studio is approaching it through deeper creative control. Neither has completely solved AI filmmaking, but both make it possible for one person or a very small team to attempt projects that would have required far more money and people only a few years ago.

I’m curious to see where this goes, especially as the underlying video models continue improving.

What do you think about tools like Drama Studio and Film Studio? Would you let an AI agent handle most of the production, or would you rather keep direct control over every shot?

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Most AI trading experiments are pretty straightforward. You give an AI some market data, ask it to come up with a strategy, run a backtest, and see what happens.

AQuA takes this much further.

Subscribe now

Instead of stopping after one experiment, it lets AI agents continue doing research on their own. They can test an idea, check the results, remember what happened, and use that knowledge when deciding what to try next.

This is closer to how a human quant researcher actually works. A researcher might spend weeks testing different ideas, throwing away the ones that fail, making small changes to the promising ones, and slowly building a better understanding of the market.

We are already seeing similar ideas outside finance. The AI Scientist, for example, explored whether AI agents could generate research ideas, write code, run experiments, and use the results to continue the scientific process.

AQuA applies a similar idea to quantitative trading, where a bad experiment can have much more subtle consequences.

The paper, titled “AQuA: Recursively Self-Improving Quantitative Trading Research Agents,” comes from researchers at Princeton University, Ant Group, and Stanford University.

They describe it as recursive self-improvement, although the AI model itself is not retraining its own weights.

Results from previous experiments are stored in memory. Later agents can read those results and use them when deciding what to investigate next. A failed experiment can still be useful because the system learns not to waste another run testing the same weak idea.

After going through the paper, I was deeply interested in how this kind of algorithm could play out in real-world applications and what developers and researchers can take away from it.

The Basic Idea Is Easier Than It Sounds

Traditional quantitative research is already an iterative process. Someone starts with a theory about the market, turns it into code, runs an experiment, checks whether the numbers make sense, and then changes the idea based on what happened.

AQuA replaces much of this manual cycle with AI agents.

The system keeps something similar to a research journal. The paper calls this persistent research state, but I find it easier to think of it as a lab notebook.

When an experiment finishes, AQuA does not just save the final score. It can also save what the original hypothesis was, what market behavior it was trying to capture, whether the idea survived testing, and which parts might be useful in another experiment. The next research run can then read that history instead of beginning with a blank slate.

This is what the researchers mean by recursive self-improvement. The LLM itself remains the same, but the research process becomes more informed over time.

There is already a growing body of work around this idea in quantitative finance. Systems such as QuantaAlpha also use previous experiments to guide later alpha-mining attempts. AQuA goes further by studying this feedback loop across two separate parts of quant research while putting strict limits around what those agents can change.

This is useful until we run into a problem that has haunted quantitative research for years: what happens when the AI learns from a bad experiment?

The “Spy in the Code” Problem

There is a surprisingly good example near the end of the paper.

An earlier version of AQuA gave the agent much more freedom. The AI could directly write feature code, while another LLM reviewed the code before it was used in an experiment.

One AI writes the feature and another checks it for mistakes. The researchers still ended up with data leakage.

The agent created a feature based on intraday trading volume. It wanted to measure how much volume had traded since the market opened and compare that number across stocks.

There was nothing obviously suspicious about the idea. The bug appeared in how the value was normalized. The agent divided the volume traded so far by the total volume for the entire trading day.

Imagine running the calculation at 10:00 AM. The numerator contains volume from the market open until 10:00 AM, which is fine. But the denominator contains everything traded from the opening bell all the way to the close.

That information does not exist at 10:00 AM.

The model had accidentally been given a small glimpse into the future.

This is known as look-ahead bias or data leakage. It can make a trading model look incredibly good during a backtest because it is using information that would never have been available at the time of the trade.

This problem is not unique to AI agents. Researchers have been warning about backtest overfitting for years, especially when researchers repeatedly test strategies against the same historical data. Campbell Harvey, Yan Liu, and Heqing Zhu also showed how the huge number of factors tested in finance makes seemingly significant discoveries much easier to find by chance, which is why they argued for much stricter statistical hurdles.

In AQuA’s case, the reviewer AI failed to catch the problem.

According to the researchers, the reviewer understood the intention of the feature and treated it as backward-looking, but it missed what the actual implementation was reading. The unusually high performance eventually raised suspicion, and a manual audit traced the problem back to the full-day volume calculation.

This failure is probably one of the most useful parts of the whole paper. The researchers did not respond by writing a longer prompt telling the reviewer to “carefully check for future data.”

They changed the system.

AQuA’s Solution Was to Lock Things Down

The current AQuA system places the agent inside what the paper calls a sealed sandbox.

The easiest way to understand it is that the AI can experiment, but it cannot change some of the important infrastructure around the experiment. The data splits, feature and label definitions, and evaluator are fixed by humans before autonomous research begins.

It also cannot freely write whatever data-processing code it wants.

Instead, AQuA gives the agent a limited set of approved mathematical operations. The paper calls this a Domain-Specific Language, or DSL, but the basic idea is simple: give the agent a toolbox containing operations that are known to be safe.

It can calculate things such as past price changes, rolling volatility, correlations, rankings, and other market statistics, but those tools are designed so that historical calculations only look backward.

The dangerous full-day volume calculation from the earlier experiment is therefore no longer something the agent can create through the available operations. The researchers effectively moved the protection away from the AI’s judgment and into the software architecture.

I like this approach because it feels much more practical than relying on prompts. We already see the same problem with coding agents. We can tell an agent not to touch a production database or not to modify certain files, but a stronger protection is simply not giving it those permissions.

AQuA applies the same thinking to AI research.

There is another problem the researchers also had to deal with. Even if the AI cannot see future market data, it can still overfit if it repeatedly sees the final test score.

If an agent tries enough strategies and checks the same test set every time, eventually it may find something that looks good mostly because of luck. This is another version of the same multiple-testing problem quantitative researchers have dealt with for decades.

AQuA therefore separates the scores used during experimentation from the final evaluation. In the US equity experiment, the agent searches using validation data, while the untouched 2021 to 2025 period is reserved for the final test.

AQuA Uses Two Independent “Brains”

Another interesting decision is that AQuA does not use one giant AI agent for the whole research process.

It splits the work into two separate systems.

1. Part I discovers trading factors

2. Part II develops the machine-learning model.

You can roughly think of Part I as the researcher looking for market ideas and Part II as the engineer trying to build a better prediction model.

The two systems are deliberately independent. They do not share agents, research memory, candidate spaces, or internal research state.

Part I Looks for Trading Signals

The factor-discovery side uses several specialist agents coordinated by an AI Manager.

Instead of asking an LLM to randomly invent trading formulas, the system begins with an economic idea.

For example, one experiment in the paper studies what happens after a large drop in open interest, which can happen when leveraged traders are forced out of their positions.

The system notices that some price rebounds are supported by strong buying afterward, while others bounce briefly without much buying pressure.

From there, it proposes a theory: if the market rebounds after forced selling but buyers do not strongly support that rebound, the price may be more likely to fall again.

AQuA then converts that idea into a mathematical factor and tests it against historical market data.

The strongest individual factors from this group produced Information Coefficients of roughly 0.026 to 0.037. AQuA then combines multiple useful factors rather than expecting one formula to predict everything.

The other important part is memory. When a hypothesis works or fails, that information is recorded so later runs can use it. The paper says later experiments can avoid repeatedly testing mechanisms that have already failed and spend more time exploring ideas that have stronger evidence behind them.

Across 20 autonomous research rounds, the combined factor signal eventually reached a Spearman IC of about 0.190 on the crypto dataset.

The upward trend in Figure 3 is a nice visual example of what recursive research looks like. AQuA keeps carrying useful evidence forward rather than resetting after every experiment.

Part II Tries to Build a Better Trading Model

The second half of AQuA focuses on US stocks. The task is to predict each stock’s return over the next 30 minutes.

Here the AI is no longer trying to discover a simple trading factor. It is testing different versions of a deep-learning model.

The technical architecture can get complicated quickly, but the basic idea does not need to be.

AQuA combines convolutional neural networks, which can detect short-term patterns in the data, with sequence models that can learn how those patterns change over time.

Its configurable architecture can draw on technologies such as Mamba-style state-space models and the attention mechanism introduced by Transformers, although the configuration reported in the AQuA experiments uses attention.

Instead of allowing the AI to rewrite the training program for every experiment, it changes a controlled configuration. It might change part of the model architecture, the loss function, or another approved training setting while the rest of the experiment stays fixed.

This again reduces the chance that an unrelated code change makes two experiments impossible to compare.

The researchers trained on data from 2010 through 2019, left 2020 as a gap, and used 2021 through 2025 as the final held-out test period.

The results were pretty interesting:

• The crypto factor-discovery system reached a combined Spearman IC of about 0.190.

• AQuA’s US equity model reached a raw per-stock IC of +0.0843, compared with +0.0613 for the strongest GRU baseline, a relative improvement of 37.5%.

• When converted into a dollar-neutral long/short strategy, the model reached a held-out Sharpe ratio of +2.50 after transaction costs and volatility targeting.

• A stricter walk-forward test, where parameters could only use past information, still produced a Sharpe of about +2.0.

For anyone unfamiliar with Sharpe ratios, the number is basically a way of comparing investment returns with how much risk was taken to earn them. Higher is generally better, although backtested Sharpe ratios should always be treated carefully.

And these results are still simulations, not live trading.

The 2022 Result Caught My Attention

The paper also breaks the strategy down year by year.

It recorded a positive Sharpe in every year from 2021 through 2025, but 2022 was actually its strongest year, with a Sharpe of +3.5.

The other years came in at:

• +1.7 in 2021

• +1.9 in 2023

• +1.8 in 2024

• +2.7 in 2025

That is interesting because 2022 was a brutal year for technology stocks. According to Nasdaq’s own year-end review, the Nasdaq-100 lost 33% during 2022, its worst year since 2008.

AQuA’s strategy did not depend on the overall market going up. It was built as a dollar-neutral long/short strategy, meaning it could hold some stocks long while shorting others.

The paper’s equity curve shows the strategy moving upward through the 2022 selloff while QQQ dropped heavily.

Still, this is not a direct apples-to-apples comparison. QQQ is a long-only index product, while AQuA’s portfolio is market neutral and takes a very different type of risk. The researchers themselves point this out in the chart.

What Developers and Researchers Can Take Away From AQuA

AQuA is obviously built for quantitative finance, but I think some of its engineering ideas apply to autonomous agents in general.

The clearest lesson is that software restrictions can be much more reliable than prompt instructions.

If an AI agent should never modify a dataset, do not simply tell it not to. Make the dataset read-only. If an evaluation score should not influence experimentation, keep that score outside the agent’s environment. If some operations can introduce invalid results, give the agent a smaller set of approved tools instead of unrestricted code execution.

This becomes more important as agents become capable of running longer experiments without someone watching every action.

The whole point of autonomous research is to let the AI explore. But more autonomy also means a small mistake can survive for longer and influence more decisions. In AQuA’s case, a leaked feature could have been written into research memory as a successful discovery and then affected future experiments.

So for developers building research agents, the environment around the model may be just as important as the model itself.

What’s Next?

The next logical step for AQuA is to connect its two systems.

Right now, the factor-discovery system and model-development system operate independently. Eventually, factors discovered by Part I could become inputs for the deep-learning models in Part II.

The researchers already discuss this possibility, but there is a catch.

If both systems search the same historical data at the same time, they could start overfitting together. Part I might discover a factor because it happens to look unusually good on that data, and Part II could then build a model around the same lucky pattern.

The paper suggests a safer approach: finish the factor search first, freeze the selected factors, and only then give them to the model-development system. Part II would treat them as fixed inputs instead of being able to influence the factor search.

There are other limitations too. The crypto system was tested on one five-minute market setup, while the equity system predicts at a 30-minute horizon. A human still defines the research goal and controls the sandbox, and none of the reported strategies have been validated with live trading capital.

So I would not look at AQuA as an autonomous hedge fund that is ready to start trading tomorrow. It is much closer to an experiment in how AI could automate parts of the quant research process without completely losing control of the experiment.

Final Thoughts

I had a lot of fun reading this paper. It shows a more realistic version of what self-improving AI agents may look like.

The AI does not suddenly rewrite itself or become a better model after every experiment. It improves because it remembers what happened before, uses those results to plan another experiment, and slowly builds a more useful research history.

But the paper also shows why giving an agent unlimited freedom can backfire. The early feature-leakage failure passed through both an author AI and a reviewer AI before humans eventually found the mistake.

The fix was surprisingly simple and practical: give the agent less access.

Let it explore ideas, but lock down the data pipeline. Let it try new models, but hide the final test results. Let it learn from its experiments, but make sure a bad experiment cannot quietly change the rules for everything that comes after it.

Developers will also need to build environments where the AI can make mistakes without those mistakes corrupting everything it learns next.

I recommend giving it a read if you’re into trading and building more reliable AI agents.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

AI chat apps have become part of everyday life for most of us. ChatGPT alone now reaches more than one billion active users, while Claude and Gemini are increasingly used for writing, research, coding, planning, and other daily tasks.

As these tools become more useful, our conversations with them are also becoming more personal.

People are no longer asking only simple questions. They are uploading work documents, sharing project details, discussing health concerns, and asking AI to analyze financial information.

Subscribe now

Personalization adds another concern. We want an assistant that remembers our preferences and understands the projects we are working on. But that also means trusting it with more context about our work and personal lives.

Popular AI chat apps offer privacy controls, but those controls can depend on your account, settings, and the type of chat you use. The situation gets more serious when your research involves sensitive material such as medical reports, bank statements, contracts, or confidential company documents.

So, which AI chat app should you use?

Ideally, you want one that is as capable as the major AI chat apps but gives you more control over your files, memories, and choice of models.

I found one that takes this approach. It is called HaloMate.

HaloMate combines multiple AI models with persistent project files and specialized assistants called Mates. Each Mate can have its own instructions and isolated memory, which helps prevent unrelated context from leaking into the wrong project.

In this guide, I will explain what HaloMate is, how it works, and who it is for. I will also show you how I used it to generate an LLM architecture diagram, summarize a research paper, and create a presentation about knowledge distillation.

Let’s get started.

What is HaloMate?

HaloMate is a cloud-based AI workspace built around persistent assistants called Mates.

It brings model families such as GPT, Claude, Gemini, DeepSeek, and Grok into one interface, then adds separate memories, project files, research tools, and a working environment that can produce documents instead of stopping at a text response.

Here are some of its key features:

• Multi-model chat: Switch models during a conversation or compare responses side by side without rebuilding the prompt in another app.

• Personal AI Mates: Create specialized assistants with their own instructions, roles, and isolated memories, or start with a prebuilt Mate from the Mate Hub.

• Persistent files and projects: Keep PDFs, documents, spreadsheets, images, code, conversations, and generated outputs together, with file version history and recovery.

• Research and file creation: Search the web and academic sources, generate diagrams, analyze data, and create editable Word, Excel, PowerPoint, and PDF files within the chat workflow.

How HaloMate Works?

To get started, head over to HaloMate and sign in.

Once you are inside, the dashboard feels immediately familiar.

There is a message box, a conversation area, and the usual expectation that I can type a question and get an answer within seconds. That familiarity helps. I did not have to learn a strange canvas before I could do anything useful.

I started with a few ordinary questions, then moved into the kind of task I actually care about: building a presentation on large language models.

This is where HaloMate began to separate itself from a standard chatbot window.

The model selector gives access to several major model families instead of locking the conversation to one provider. The exact lineup can change as providers release new versions, but the practical idea stays the same.

I can use a large reasoning model for a difficult explanation, move to a smaller and cheaper model for a quick rewrite, or ask another model to challenge the first answer. I can also adjust the reasoning effort when the task justifies the extra time and credit use.

The feature I kept returning to, though, was the collection of Mates.

A Mate is a reusable AI assistant configured for a particular job. HaloMate describes it as a prompt paired with a model and additional settings, but that definition only covers the setup.

In use, it feels closer to a dedicated workspace with a role, a set of skills, and its own memory.

I can create one Mate for technical writing, another for presentation design, and another for personal research. Each can remember the instructions and preferences relevant to its job without dragging unrelated context into the next assignment.

I do not have to keep telling a diagram assistant that I prefer readable labels. I also do not need to remind a writing assistant about the audience and tone every time I open a new chat.

To explore the prebuilt options, I opened the Mate Hub and looked for something that matched my project.

I was preparing a presentation about LLMs and needed a clear diagram showing how model training works. Instead of prompting a general assistant and hoping it chose the right visual format, I selected the Architecture Diagrams Mate.

For the text prompt, I used this:

Prompt: Explain to me in a diagram how LLM training works

A few seconds later, I had a well-illustrated overview that was much closer to presentation-ready than the usual wall of text.

The flow was easy to follow, the stages were labeled, and I could download the result in multiple formats. Pretty cool, right?

I still checked the wording and sequence because diagrams can make an error look more authoritative than it is. Even so, the first draft gave me something concrete to improve instead of a blank slide.

I could also create a custom Mate for this presentation and keep using it as the deck evolved. I would give it the audience, learning goals, preferred visual style, and required level of technical detail. The next diagram would begin with that context already in place.

This is personalization at the project level, which is more useful to me than a single global memory trying to infer what every future conversation needs.

Files follow the same persistent idea.

HaloMate accepts PDFs, spreadsheets, documents, images, and code, but it treats them as part of a file system rather than a temporary attachment tied to one answer.

A Mate can search across the files, use them as a knowledge base, create new versions, and keep generated outputs with the project. If an edit goes wrong, the version history provides a path back.

For another test, I uploaded a research paper and asked for a summary.

The experience was similar to other AI chat apps at first: attach a file, enter a request, and wait for the response.

The difference showed up after the answer. The paper, conversation, and output could remain part of an ongoing project instead of becoming one more chat I would struggle to find two weeks later.

This persistence is also where privacy needs to be discussed precisely.

Another thing to note is that HaloMate can switch between models mid conversation. Same chat, same Project files, same prompt. Regenerate or continue with another model. Side-by-side reasoning on a
decision, a thin draft, or a claim you do not fully trust.

This is incredibly useful when you care whether another brain would catch a hole, not when you only need a quick definition.

HaloMate says it does not sell private data or use private content to train AI models. It isolates memory by Mate and gives users controls to review, edit, and delete memories, roll files back, or remove content.

Those are useful product decisions because privacy is partly about preventing the wrong context from appearing in the wrong place, not only about what happens during model training.

• No training on private content: HaloMate states that user content is not used for AI model training unless the user explicitly authorizes it.

• Isolated memory: Each Mate maintains its own context, reducing unwanted crossover between personal, professional, and project-specific work.

• User controls: Memories can be reviewed or deleted, files have recoverable versions, and account termination triggers the deletion timelines described in HaloMate’s terms.

If I were working with a medical record, financial statement, or client-confidential document, I would still remove identifiers where possible and check the relevant legal, contractual, and data-residency requirements.

I would also verify critical conclusions with a qualified professional. No privacy label turns an AI-generated medical, financial, or legal answer into professional advice.

The last part of my test brought the workflow together.

My LLM presentation included a section on knowledge distillation, and I needed more than a diagram. I wanted a short deck explaining how a larger teacher model transfers useful behavior to a smaller student model, why teams use the technique, and what can be lost during the process.

I uploaded my reference material and asked HaloMate to create the presentation.

The app recognized the file-creation request and routed the task to the appropriate capability. Instead of returning an outline for me to paste into PowerPoint, it generated an actual presentation file.

Halo Computer is the execution layer inside the chat: run analysis,
structure data, generate charts, pull and tidy web info, and hand back real files (Word, Excel, PowerPoint, HTML, and similar) without you leaving the thread.

Within seconds, I had a 10-slide deck on knowledge distillation.

I would not present it without review. Slide generators can oversimplify technical details, repeat the same layout, or place too much confidence in a neat diagram.

I checked the claims, adjusted the density, and made sure the story matched the audience.

Even with that editing, the time savings were significant. The slowest part of presentation work is often getting from scattered notes to a coherent first version.

HaloMate handled that blank-slide stage, kept the sources close to the project, and gave me a file I could continue editing.

Who is it for?

HaloMate is a good fit for researchers, technical writers, students, consultants, and creators who use AI for projects that last longer than one conversation. Its persistent files and isolated Mate memories reduce the need to upload the same material or repeat the same instructions.

It also makes sense for people who regularly switch between ChatGPT, Claude, Gemini, and other models. HaloMate brings those models into one workspace, making it easier to compare answers and choose the right model for each task.

If you work with highly regulated medical, financial, or legal information, review HaloMate’s privacy policy and your organization’s requirements before uploading anything sensitive.

Why should you care?

No AI model is best at everything. Some are better at reasoning, while others perform better at writing, coding, or visual work. HaloMate lets you switch models without moving your project between several apps.

Its isolated Mate memories are also useful. Your presentation assistant does not need context from your personal research, and your writing assistant does not need every detail from an unrelated project.

HaloMate then keeps your conversations, source files, and generated documents together. Instead of losing useful work inside an old chat, you can return to the project and continue where you left off.

Final Thoughts

That’s about it. In this post, I used HaloMate to compare AI models, generate an LLM training diagram, summarize a paper, and create a presentation about knowledge distillation.

Its main advantage over single-provider chat apps is flexibility. You can choose from several model families while keeping your files, conversations, and specialized assistants in one place.

I also appreciate platforms like HaloMate for giving users another option. We should not have to rely entirely on ChatGPT, Claude, or Gemini when different projects require different models, privacy controls, and memory boundaries.

What do you think about HaloMate? Would you use a multi-model AI workspace, or do you prefer keeping each AI assistant separate? Share your thoughts in the comments.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

You’ve finally finished the agent. The demo cost almost nothing to run, so you shipped it. Then the first month of real traffic arrives, along with an invoice that looks suspiciously like a mortgage payment.

Subscribe now

This side of AI engineering gets far less attention than it should. We talk a lot about model quality, latency, and evals. The actual line items on the bill usually come later, once the system is already in production.

The good news is that you can cut inference costs without quietly making your agent worse. Below are five changes that target different parts of the stack, and the savings can be combined.

Ways to Reduce AI Inference Cost

Before getting into the details, here’s how the five approaches compare:

1. Route Each Query to the Cheapest Model

For many agents, most of the money disappears because of one decision: every request goes to a frontier model. That is convenient during development, but plenty of production queries do not need that much model.

Model routing, also known as a cascade, puts a lightweight classifier or cheaper model in front of your model pool. Straightforward requests stay on the cheaper path. More complex ones get escalated to the larger model.

Watch out in agents: A routing miss in a chatbot is usually recoverable because the user can ask again. In an agent, the cheaper model might choose the wrong tool or pass the wrong argument. The next step fails, a retry kicks in, and the route that looked cheaper ends up costing more.

When one model still makes sense: If you handle fewer than roughly 10,000 requests a day, the engineering and monitoring work behind a router may cost more than it saves. I would check the request mix before building one.

2. Cache the Parts of Your Prompt That Never Change

Say you run a 5,000-token system prompt across 10,000 requests a day. You have already paid for 50 million input tokens before the model processes a single word from a user.

Prompt caching avoids paying full price to process the same prefix every time. That prefix might contain your system instructions, tool definitions, schemas, or few-shot examples. Once cached, repeat requests become much cheaper.

Tip: Caching only works on a stable prefix. Put fixed content such as instructions, tools, and schemas at the front. Keep changing content, including the user turn and retrieved chunks, toward the end.

3. Right-Size and Quantize the Model You Actually Run

Do you need a frontier model, or did you only need one to make the demo look good? In production, a right-sized open-weight model with quantization can be the difference between serving on one modest GPU and paying for a cluster.

Quantization stores model weights using fewer bits:

• FP8 (8-bit floating point) roughly halves memory use compared with 16-bit and is close to lossless in quality.

• INT4 (4-bit integer, weight-only) works well for low-batch, latency-sensitive serving.

• 4-bit AWQ has been shown to retain about 98% of full-precision quality.

Serving software matters too. Engines such as vLLM use continuous batching, which can deliver more than 20 times the throughput of naive static batching. Its PagedAttention approach also reduces key-value (KV) cache memory waste from roughly 60%–80% to under 4%.

Those numbers are impressive, but I would still test the quantized model on the same evals you use for production. Average benchmark scores will not tell you whether it still handles your tool calls, document formats, or edge cases correctly.

4. Send Fewer Tokens by Retrieving Better

RAG systems often overspend in a boring way: they send too much context. Every irrelevant chunk in the prompt is another set of tokens billed at your generation model’s rate.

You can reduce that waste without weakening the answer. Retrieve more precisely so fewer near-misses enter the candidate set, then rerank those candidates with a cross-encoder and send only the strongest few to the model.

A common setup retrieves 20–50 candidates cheaply with dense embeddings, then reranks them down to the best 5–10 before generation. The prompt gets shorter, the model has less irrelevant text to work through, and answer quality often improves.

Tip: Reranking adds another inference step and a little latency. If your corpus is small and vector search already returns the right passages, you may not need it.

5. Self-Host the Small-Model Fleet

An agent rarely depends on one model alone. Behind the main LLM, you may have several smaller models doing repetitive work:

• An embedder for search

• A reranker for precision

• An extractor for structured fields

• An OCR model for documents

Your mix will depend on the use case, but the pattern is the same. These models handle a high volume of predictable requests, which makes per-call pricing harder to justify once traffic becomes steady.

Self-hosting these models is also a different problem from self-hosting a 70B-parameter LLM. The models are smaller, and several can share the same hardware. Embeddings are already much cheaper than completions per token, so utilization matters more than chasing a dramatic price difference on a single request.

That utilization is also the hardest part. Renting an H100 costs around $2–$3 per hour on GPU clouds in 2026. If the GPU sits idle for most of the day, the supposed savings disappear quickly.

For one large LLM with uneven traffic, a managed API is usually cheaper until usage becomes substantial. A fleet of smaller models changes the calculation. You can place several models on the same GPU, batch requests across them, and keep the hardware busy for more of the day.

Small-Model Layer Without Heavy Ops

The economics may look good, but most teams do not want a separate deployment and operations project for every small model.

SIE (Superlinked Inference Engine) is one option. It is an open-source inference server built specifically for small-model workloads such as:

• Embeddings

• Reranking

• Extraction

• Generation

You operate SIE as a single system, whether it is running on a laptop or in a production Kubernetes cluster. Instead of maintaining one service per model, you can place multiple models on shared GPUs and use on-demand loading and idle eviction to manage memory.

A Managed API Still Wins Sometimes

I would not self-host by default. The better choice depends on your traffic pattern, team size, and how many models you actually need.

Final Thoughts

You do not have to tackle all five changes at once. I would start with the cheap wins. Fix the prompt layout and turn on caching first, then look at routing once you have enough production traffic to understand which requests are genuinely easy.

Self-hosting belongs later in the process, when the volume is steady, and the small-model fleet is large enough to keep the hardware busy. SIE is open source and free to run yourself. Superlinked also offers a managed cluster and free hosted capacity for selected projects if GPU quotas and operations are the parts you would rather avoid.

The retrieval layer is easy to ignore because no single call looks especially expensive. Add embeddings, reranking, extraction, and unnecessary context across every agent run, though, and it can become a meaningful part of the bill. That is where I would look after caching and routing.

Frequently Asked Questions

What’s the single fastest way to cut AI inference costs?

Prompt caching is usually the fastest win. On current flagship models, cached prompt prefixes can cost about 90% less to process. It requires little code, and because you are not changing the model or removing context, the output should stay the same.

Is self-hosting cheaper than using an API?

Not automatically. For one large model, a managed API is often cheaper because an idle GPU is pure waste. Self-hosting tends to pay off sooner for a fleet of small models, where embeddings, reranking, and extraction can share the same GPU and keep it busy.

Will using cheaper models reduce agent quality?

It can, especially when a smaller model is asked to handle tool selection, structured output, or a request outside its usual range. The safer approach is to route only the requests that your evals show it can handle reliably, then send uncertain cases to a stronger model. Price alone is a poor routing rule.

When does self-hosting start to make financial sense?

There is no universal request threshold. It depends on model size, traffic consistency, batching, and GPU utilization. I would compare your monthly API spend with the full cost of running the hardware, including idle time and engineering work. Self-hosting starts to look sensible when demand is steady enough to keep the GPU busy.

Do these levers stack?

Yes. Routing reduces how often you call the expensive model. Caching lowers the cost of repeated input. Better retrieval shortens what remains, while right-sizing or self-hosting lowers the cost of serving the models themselves. Each change hits a different part of the bill.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

I needed to turn a research paper into a diagram, a summary, and a slide deck. Paper in. Diagram, summary, and slides out. Same source files, one workspace, and a second look from more than one model before I trusted the deck.

I ran the whole sequence in HaloMate. It combines multiple AI models with persistent project files and specialized assistants called Mates. Each Mate can have its own instructions and isolated memory, which helps prevent unrelated context from leaking into the wrong project.

Subscribe now

Here is the sequence I actually ran: a diagram, a summary, a second look from ChatGPT, Claude, and Gemini, then a slide deck from the same files.

Let’s get started.

What I used instead of three chat apps

I ran this in HaloMate. It is a cloud-based AI workspace built around persistent assistants called Mates.

It brings model families such as GPT, Claude, Gemini, DeepSeek, and Grok into one interface, then adds separate memories, project files, research tools, and a working environment that can produce documents instead of stopping at a text response.

What I actually used for this paper:

Multi-model chat: Switch models during a conversation or compare responses side by side without rebuilding the prompt in another app.

Personal AI Mates: Create specialized assistants with their own instructions, roles, and isolated memories, or start with a prebuilt Mate from the Mate Hub.

Persistent files and projects: Keep PDFs, documents, spreadsheets, images, code, conversations, and generated outputs together, with file version history and recovery.

Research and file creation: Search the web and academic sources, generate diagrams, analyze data, and create editable Word, Excel, PowerPoint, and PDF files within the chat workflow.

To get started, head over to HaloMate and sign in.

Once you are inside, the dashboard feels immediately familiar.

There is a message box, a conversation area, and the usual expectation that I can type a question and get an answer within seconds. That familiarity helps. I did not have to learn a strange canvas before I could do anything useful.

I skipped the warm-up questions and went straight to the project: a presentation on large language models. Before anything else, I had to pick a model.

The model selector gives access to several major model families instead of locking the conversation to one provider.

I can use a large reasoning model for a difficult explanation, move to a smaller and cheaper model for a quick rewrite, or ask another model to challenge the first answer. I can also adjust the reasoning effort when the task justifies the extra time and credit use.

Before touching the paper, I set up who would do the work. That is where Mates come in.

A Mate is a reusable AI assistant configured for a particular job. A Mate is persona plus memory, not a prompt paired with a model. The model is only the engine for that turn. I can switch models and keep the same assistant.

I can create one Mate for technical writing, another for presentation design, and another for personal research. Each can remember the instructions and preferences relevant to its job without dragging unrelated context into the next assignment.

I do not have to keep telling a diagram assistant that I prefer readable labels. I also do not need to remind a writing assistant about the audience and tone every time I open a new chat.

How I turned the paper into a diagram

To explore the prebuilt options, I opened the Mate Hub and looked for something that matched my project.

I was preparing a presentation about LLMs and needed a clear diagram showing how model training works. Instead of prompting a general assistant and hoping it chose the right visual format, I selected the Architecture Diagrams Mate.

For the text prompt, I used this:

Prompt: Explain to me in a diagram how LLM training works

A few seconds later, I had a well-illustrated overview that was much closer to presentation-ready than the usual wall of text.

The flow was easy to follow, the stages were labeled, and I could download the result in multiple formats. Pretty cool, right?

I still checked the wording and sequence because diagrams can make an error look finished. I would rather start from something concrete to improve instead of a blank slide.

I could also create a custom Mate for this presentation and keep using it as the deck evolved. I would give it the audience, learning goals, preferred visual style, and required level of technical detail. The next diagram would begin with that context already in place.

This is personalization at the project level, which is more useful to me than a single global memory trying to infer what every future conversation needs.

How I summarized the research paper without starting over

Files follow the same persistent idea.

HaloMate accepts PDFs, spreadsheets, documents, images, and code, but it treats them as part of a file system rather than a temporary attachment tied to one answer.

A Mate can search across the files, use them as a knowledge base, create new versions, and keep generated outputs with the project. If an edit goes wrong, the version history provides a path back.

For another test, I uploaded a research paper and asked for a summary.

The experience was similar to other AI chat apps at first: attach a file, enter a request, and wait for the response.

ChatGPT can summarize a PDF too. The difference was what I could do next without starting over. The paper stayed in the project as a file, not a one-off attachment. The summary sat next to it. When I wanted another model to check the summary, and later when I asked for slides, I pointed at the same files. I did not re-upload the PDF or rebuild the prompt three times.

How I got a second opinion from ChatGPT, Claude, and Gemini

I also stayed in the same workspace and ran one question through Claude, GPT, and Gemini. Same project files. Same prompt. Three answers, side by side. I wanted to see whether another model would catch a hole the first one missed.

Uploading the paper also made me look at where the request actually runs. Under Privacy & Compliance there is a Regions setting for model hosting: Mainland China, Singapore, and the United States. You can leave all three on or turn some off. The product warns that restricting regions may increase credit use and make some models unavailable. I left all three on for this test. It is a control I can see and change, not a privacy slogan.

How I turned the same paper into a slide deck

The last part of my test brought the workflow together.

My LLM presentation included a section on knowledge distillation, and I needed more than a diagram. I wanted a short deck explaining how a larger teacher model transfers useful behavior to a smaller student model, why teams use the technique, and what can be lost during the process.

I uploaded my reference material and asked HaloMate to create the presentation.

The app recognized the file-creation request and routed the task to the appropriate capability. Instead of returning an outline for me to paste into PowerPoint, it generated an actual presentation file I could open. One slide laid out the teacher / student trade-off, which was the point of that section. I did not have to leave the chat to get a real pptx.

Within seconds, I had a 10-slide deck on knowledge distillation.

I would not present it without review. Slide generators can oversimplify technical details, repeat the same layout, or place too much confidence in a neat diagram.

I checked the claims, adjusted the density, and made sure the story matched the audience.

Even with that editing, the time savings were significant. The slowest part of presentation work is often getting from scattered notes to a coherent first version.

HaloMate handled that blank-slide stage, kept the sources close to the project, and gave me a file I could continue editing.

When a PDF-to-PPT converter is enough

If all I needed was PDF to PPT, a dedicated converter or NotebookLM would have been enough. I used this because the job was bigger than a one-off conversion. The paper, the diagram, the summary, and the deck all lived in the same project, and they kept building on each other as the conversation went on. That is the part a converter cannot do.

Who this workflow is for

HaloMate is a good fit for researchers, technical writers, students, consultants, and creators who use AI for projects that last longer than one conversation. Its persistent files and isolated Mate memories reduce the need to upload the same material or repeat the same instructions.

It also makes sense for people who regularly switch between ChatGPT, Claude, Gemini, and other models. HaloMate brings those models into one workspace, so I can pick a model for each task.

If your work has to stay in a particular country, check the Regions setting before you upload the file. Restricting a region can also take some models offline.

If you’re looking for a capable ChatGPT alternative for complex research and multi-step projects, HaloMate is well worth testing.

Final Thoughts

That’s about it. In this post, I used HaloMate to compare AI models, generate an LLM training diagram, summarize a paper, and create a presentation about knowledge distillation.

Its main advantage over single-provider chat apps is flexibility. You can choose from several model families while keeping your files, conversations, and specialized assistants in one place.

I also appreciate platforms like HaloMate for giving users another option. We should not have to rely entirely on ChatGPT, Claude, or Gemini when different projects require different models, hosting regions, and memory boundaries.

What do you think about HaloMate? Would you use a multi-model AI workspace, or do you prefer keeping each AI assistant separate? Share your thoughts in the comments.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

I’ve made quite a few promotional AI videos and UGC ads for clients over the past couple of years. Trust me when I say that there are only a few platforms I can consistently rely on.

Some tools generate attractive footage but give you almost no control. Others work well for one specific task, forcing you to jump between several websites just to finish a 20-second video. Once you add the video enhancements, captions, cleanup, and localization, the process can become surprisingly messy.

One platform I discovered to be really good is Vmake Labs.

Subscribe now

You might recognize it by its former name, Vmake AI. The company recently renamed the platform to Vmake Labs, and the change reflects how much the product has expanded.

It is now positioning itself as an all-in-one social video studio that helps creators and small businesses generate, enhance, clean, translate, and optimize videos.

I wanted to see how that broader workflow actually comes together. For this article, I explored its video generation tools and paid closer attention to two recent updates: Master mode in Video Enhancer and Smart Pro in Video Watermark Remover.

What Vmake Labs Is

Vmake Labs is an AI social video studio built for small businesses, e-commerce sellers, marketers, affiliate creators, and social media managers.

Rather than focusing only on video generation, the platform covers several stages of production. You can start with a product image or written prompt, generate the first clip, improve its visual quality, remove unwanted elements, add captions, and prepare translated versions.

According to the current Vmake Labs website, the platform is designed around TikTok, Instagram Reels, YouTube Shorts, Shopify, and Amazon Inspire. It also offers free access and starter credits to try some of its features before upgrading.

Vmake Labs describes the workflow as a way to turn ideas, products, storefronts, and existing footage into ready-to-use videos.

Some of the most notable tools include:

• AI Video Generator: Creates videos from text prompts, images, first and last frames, or existing clips. Several major video models are available from the same workspace.

• UGC Video Generator: Turns product information and images into UGC-style promotional videos.

• AI Avatar Video: Creates presenter-led and shoppable videos without filming a real spokesperson.

• Video Enhancer: Restores detail, reduces blur and compression artifacts, and upscales footage to higher resolutions.

• Video Watermark Remover: Removes text, subtitles, logos, people, and unwanted objects using automatic or manual selection.

• Video Translator: Translates subtitles and speech, generates dubbed audio, matches voices, and synchronizes mouth movement.

The useful part is that Vmake Labs treats these features as stages in the same production process. You can generate, improve, clean up, and localize a clip without first learning four completely different platforms.

How to Create AI Videos with Vmake Labs

To get started, head to Vmake Labs and create an account. From the dashboard, you can generate a video from a written prompt, animate an image, restyle existing footage, or choose one of the ready-made templates.

I decided to create a short product ad for a wireless speaker. Start by uploading the product image. When you upload an image, the platform scans it to better understand the physical attributes. The image below accurately depicts the speaker I uploaded, and this is crucial for generating the final video.

For the video style, I chose the “Japanese summer commercial by Seedance 2.5” because I wanted it to look like young consumers promoting it.

Here was my prompt:

Prompt: Generate a Japanese Summer TVC video featuring my uploaded product

Notice that I left the Avatar section empty because I wanted to make use of the default actors in the template. Of course, you can replace this with your own custom avatar.

In the settings submenu, you can adjust settings such as the video model and the output aspect ratio. In this example, I wanted it to be in a 3:4 aspect ratio and use the Seedance 2.5 video model.

The last step is to click the Create button and wait for the final UGC video.

Here’s what the output looks like:

It looks awesome! Vmake Labs followed the camera direction closely, and the afternoon light gave the speaker a warmer, more expensive look. I also liked the restraint in the camera movement. It felt like someone was filming the product rather than dragging a digital camera through a still image.

This could easily pass as a real production-grade commercial for my speaker product. All done in minutes and a few dollars!

Improving the video with Master mode

The Vmake Labs Video Enhancer offers three general processing modes.

Fast handles quick cleanup, while Quality rebuilds more of the missing detail. The new Master mode aims for a more cinematic result and supports 2K, 4K, and 8K output.

Uploading a video is straightforward. Open the Video Enhancer, drag the file into the upload area, then choose a model and resolution. Vmake Labs can also select a model automatically, but I chose Master at 4K so I could judge the new mode directly.

Here’s the input video before it got enhanced:

Here’s the enhanced video in 4K:

See the difference? The video is in higher resolution, and the quality is much sharper. This isn’t possible with just upscaling the resolution; Vmake Labs made several visual upgrades to improve the final video.

Cheap enhancement often creates bright outlines and rough edges, making the video look harsher without recovering any meaningful detail. Master kept the soft background while concentrating most of the improvement on the product.

Removing Watermarks and Text with Smart Pro

Next, I tested the Vmake Labs Video Watermark Remover.

The tool includes automatic modes for common removal jobs, plus manual controls for marking a specific area yourself. Its new Smart Pro mode is built for more demanding cases, including small lettering, semi-transparent marks, moving watermarks, and animated subtitles.

For a clear before-and-after comparison, I chose a product image featuring two ceramic vases against a warm brown background. A large white “VASE” watermark stretched across the middle, covering part of the smaller vase and overlapping the edge of the larger one.

After uploading the image, I selected the watermark removal option and started processing. Here’s the side-by-side comparison of the before and after editing.

The result came out cleaner than I expected. Removing the letters from the plain background was the easy part, but Vmake Labs also had to reconstruct the rough surface of the smaller vase and the curved edge of the larger one. Both areas remained convincing, with no obvious white fragments or heavy blur where the text had been.

Removing a large watermark that crosses both a simple background and detailed objects is a solid result.

More Tools for Finishing Social Videos

Vmake Labs has several other tools that fit into the same production workflow, even though I did not test each one separately for this article.

Portrait Pro is part of the Video Enhancer and focuses on talking-head footage. It builds on the standard Portrait scene by restoring facial detail, improving clarity, and generating more natural skin texture.

This could help with compressed UGC ads, interviews, and creator videos where the face looks soft after repeated exports. As with any facial enhancement, I would still review the full clip for flicker or changes around the eyes, teeth, and hairline.

Speaking of UGC ads, there’s also an AI Avatar Video creator that lets you turn a single product image into a shoppable video featuring a more natural, lifelike avatar.

The Vmake Labs Video Translator handles localization. It can remove existing subtitles, generate translated captions, dub the spoken audio, match the speaker’s voice, and adjust lip movement to the new dialogue.

It currently supports 14 languages, giving small businesses a way to adapt a single product video for several markets without re-recording each version. I would still have a native speaker check the final script, especially when the video includes sales copy, humor, or regional expressions.

Vmake Labs also includes a Video Background Remover for separating people and products from their surroundings. It can export footage with either a transparent background or a green screen, making it easier to place the subject inside a product ad, presentation, or branded scene. This is particularly handy for businesses that do not have access to a studio or a physical green screen.

None of these tools needs a separate section to make the point. Together, they show how Vmake Labs extends beyond video generation. The platform can handle several tasks that normally occur after the first clip is created, from cleaning up a presenter to translating the finished ad for another audience.

Why Should You Care?

Creating the first AI video is often the easiest part. Most of the work comes later.

There will always be a case where you notice that the product texture looks soft. A caption covers the wrong area. The client wants another language. The footage needs a cleaner export. Before long, a 15-second ad has passed through four platforms and accumulated several slightly different versions.

Vmake Labs cuts down that back-and-forth. A small business can generate a product clip, enhance the image, remove unwanted elements, add captions, and create localized versions, all from the same platform.

The new Video Enhancer options also match the type of material people are actually publishing. Master addresses generated or compressed footage that lacks detail. Studio gives phone recordings a more deliberate look. Portrait Pro improves talking-head videos without automatically turning every face into plastic.

Smart Pro solves an equally tedious problem. Manually removing moving text and animated subtitles can involve masks, tracking, and frame-by-frame repairs. Even when Smart Pro needs a small correction, finishing most of the clip automatically can remove a significant amount of editing work.

There are limits, though, and you should take note of them. Poor source footage remains poor, even after upscaling. Enhancement may invent details, and removal becomes less reliable when text covers hands or faces. Some of the newer modes also require a membership.

Those are reasonable tradeoffs, but they should not be ignored. The platform is at its best when it accelerates a real editing workflow, not when it is treated as a button that can rescue any clip.

Final Thoughts

I am glad Vmake Labs has expanded beyond its original focus. The new name feels more appropriate now that the platform covers video generation, enhancement, cleanup, and other parts of social content production.

The UGC and Product Showcase generators were my favorite tools. Both make it easy to turn basic product assets into promotional videos without filming everything from scratch. I especially liked how quickly the Product Showcase generator could take a simple product image and give it movement, context, and a format that already feels suited to social media.

The UGC generator also makes sense for small businesses that need several ad variations but do not have the time or budget to organize repeated shoots. The output will still need a human review, particularly when it comes to product accuracy and natural movement, but the starting point is much stronger than building every video manually.

Master and Smart Pro strengthen the workflow around those generators. Master can improve soft or compressed footage, while Smart Pro handles watermarks and text that would otherwise require more editing. They were not the main reasons I liked Vmake Labs, but they make the platform more complete.

I do not expect Vmake Labs to replace a full video editor. I would keep it in my workflow because it shortens the distance between a product idea and a video that is ready for further editing or publishing.

If you create product ads, UGC, or short-form promotional content, try a few of its tools and let me know which one worked best for you.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Over the past few days, my social media feed has been flooded with posts about Jonathan Wilke and a small project he built called Outbid.lol.

The concept is almost absurdly simple. You submit your app, product, website, or profile to a public leaderboard and pay to move higher. If somebody pays more than you, they take your position. If you want the top spot, you have to outbid whoever currently owns it.

Jonathan shared the project on X, and it quickly escaped the usual indie-hacker bubble. I started seeing screenshots of the leaderboard, revenue updates, people discussing whether the idea was brilliant or ridiculous, and of course other developers already thinking about variations of it.

A slew of similar websites immediately followed.

• https://claimrank.lol

• http://watchbid.lol

• http://takeone.lol

• http://lastspot.lol

• http://overbid.lol

• http://outrank.lol

• http://spots.lol

• http://bidwall.lol

• http://rankly.vip

There will be more in the coming days… that’s for sure.

What caught my attention wasn’t that the underlying software looked technically difficult. It was the simplicity of the idea.

Outbid.lol Is Simple Enough to Explain in One Sentence

A lot of products I cover require several paragraphs before the business model becomes clear. Outbid doesn’t have that problem.

People pay for rank.

This guy just paid over $10,000

How crazy is that?

Someone can post a screenshot of the leaderboard on X and anyone looking at it understands what is happening almost immediately. There is no onboarding flow to explain and no feature list to study before the joke lands.

The public bidding also creates an interesting feedback loop. As more people visit the site, the higher positions become more visible. That makes those positions more desirable, which can encourage another bid.

Every unusually large bid then becomes something people can screenshot and share, bringing another wave of attention back to the site.

Jonathan shared some striking numbers during the launch. According to his updates, Outbid crossed 200,000 visitors in roughly its first day and generated tens of thousands of dollars in revenue. The site has since passed one million visitors, according to the counter displayed on Outbid itself.

As of today, Jonathan has made over $95K already. Tomorrow, that’s guaranteed to hit $100K.

Those are impressive numbers for any launch, especially for something that began as a relatively small web experiment.

But I don’t think the takeaway is simply that adding a payment button to a leaderboard prints money.

Virality Did a Lot of the Heavy Lifting

There is an obvious circular effect here.

People are willing to pay for a high position partly because Outbid has traffic. Outbid gets more traffic partly because people are talking about how much others are willing to pay for those positions.

That dynamic becomes much harder to reproduce if the initial attention never arrives.

A leaderboard with 50 visitors is very different from a leaderboard being watched by hundreds of thousands of people. The code can be identical while the economics are completely different.

There is also novelty involved. The first time I saw Outbid, I immediately understood why people were sharing it. The idea is slightly ridiculous, competitive, transparent, and easy to participate in.

Watching founders spend increasingly large amounts of money to move one row higher is part advertising marketplace and part internet spectacle.

That combination is difficult to engineer deliberately.

If twenty identical sites launched tomorrow, I doubt all twenty would experience the same result. Outbid benefited from being early enough for the concept to feel new, while Jonathan’s public updates gave people another reason to keep following the story.

Still, there are parts of the product design that are interesting beyond the viral moment.

The Leaderboard Is Also the Distribution Mechanism

Most software products separate the product from its marketing.

A developer builds an app, then needs another system for getting people to see it: SEO, ads, social media, newsletters, affiliates, or something else.

With Outbid, those two layers overlap.

People buying positions are effectively paying for exposure, but their purchases also change the product everyone else sees. A new highest bid modifies the leaderboard, creates competition, and potentially gives people something new to talk about.

That is probably the part I found most interesting as someone who builds web products myself.

The mechanic made me think less about copying the exact interface and more about what other versions of a paid ranking system could look like.

One limitation I noticed was that everything on Outbid essentially competes inside the same broad leaderboard. That is part of its charm because the randomness makes the site entertaining, but it also means completely unrelated products can end up competing for the same positions.

An AI tool could be sitting beside a design agency, developer product, newsletter, game, or personal profile.

I started wondering whether the same mechanic would feel different if the rankings were separated by category.

So I Built a Small Variation of the Idea

That thought eventually turned into ClaimRank.lol.

I want to be clear about where the idea came from because there isn’t much value in pretending otherwise. Outbid was the inspiration. I saw what Jonathan built, liked the underlying mechanic, and started thinking about one particular variation of it.

ClaimRank keeps the idea of paying to compete for positions, but organizes rankings into categories. Instead of every product fighting for one universal leaderboard, products can compete within a more relevant group.

That might make the ranking more useful, or it might remove some of the chaos that makes Outbid entertaining in the first place. I don’t know yet.

And that is really why I built it.

Not because I think categories somehow “fix” Outbid, or because every viral product needs a more feature-heavy competitor. Outbid is clearly doing something right as it is. I was simply curious about how the mechanic changes when the competition becomes narrower.

There Is a Bigger Lesson Here for Builders

One thing I have noticed from building software over the years is how easy it is to associate complexity with value.

It is tempting to believe a better product needs another dashboard, another AI integration, another automation workflow, or another dozen settings. Meanwhile, something like Outbid can appear with a mechanic that takes seconds to understand and suddenly dominate everyone’s feed.

That doesn’t mean simple products are easy to make successful. Distribution, timing, audience, novelty, and luck still play enormous roles.

But it does show that a product can be interesting because of the behavior it creates rather than the number of things it can do.

Outbid created competition around a number on a webpage. That competition created content. The content brought visitors. More visitors made the rankings more valuable, and the cycle continued.

Whether that momentum lasts is a separate question. Viral traffic can disappear as quickly as it arrives, and a launch-week revenue graph doesn’t tell us what the business will look like months from now.

For now, though, Outbid.lol is a fascinating example of how far a very small idea can travel when the product itself gives people a reason to keep talking about it.

It was interesting enough that I ended up building my own experiment around the concept.

Now I’m curious to see what happens to both.

When doing research, I usually use a handful of AI tools to summarize papers, find information, and understand technical topics more easily.

Some of my usual tools are Google’s NotebookLM, ChatGPT, Claude, Grok, and AnswerThis.

You might already be familiar with the first four tools, but probably not the last one.

Subscribe now

Most AI chatbots can explain a topic or summarize a document. The problem starts when I need to verify the information, find the original paper, manage several sources, and use those sources in the final draft.

I often end up with too many tabs open. One contains the research paper, another has my conversation with an AI, and another contains the draft. Sometimes I copy useful information into my notes and later forget exactly where it came from.

AnswerThis tries to keep those parts of the research process together.

In this guide, I will go deeper into what AnswerThis is, how it works, and why I think it is one of the best AI tools for citation-backed research.

Let’s get started.

What is AnswerThis?

AnswerThis is an AI research assistant made for people who work with academic and scientific sources.

You can use it to find papers, generate literature reviews, upload and analyze your own research, ask questions about a paper, manage citations, and write a draft. Instead of opening a separate application for each task, you can keep the research inside one project.

The platform says its academic search covers more than 300 million research papers. You can search for a topic and narrow the results based on factors such as publication date, journal quality, source type, and minimum citation count. You can also limit the search to papers that you already saved in your library.

This is helpful because research is not only about finding more papers. It is about finding papers that are actually relevant to your question.

A highly cited paper may be useful when you want to understand the foundation of a topic. A newer paper with very few citations may be more helpful when researching something that was released only a few months ago. Being able to control the search helps reduce the amount of unrelated information that you have to screen manually.

The tool also connects its answers to the sources it used. When it gives you an explanation, you can inspect the cited paper and check the section behind the answer.

Here are some of its key features:

• Chat with papers: Upload a research paper and ask questions about its methods, findings, terminology, or limitations.

• Literature review and paper search: Search for related academic work and create citation-backed literature reviews.

• Citation Mapper and bibliometric analysis: See how papers are connected and analyze publication, citation, journal, and author trends.

• Research library: Save uploaded files and newly discovered papers inside the same project.

• AI Writer and export tools: Turn your research into a draft and export it as PDF, DOCX, Markdown, or LaTeX.

Most of these tools are built around the same library. If I save a paper during the research stage, I can still access it later when I start writing.

How To Use AnswerThis for Research

Head over to AnswerThis, sign in, and create a new project.

You can then add the reference materials you want to use. For academic work, the main option is uploading a PDF. You can also save papers found through AnswerThis or import existing references from tools such as Zotero and Mendeley.

For this example, I wanted to research Distilling the Knowledge in a Neural Network.

This is the 2015 paper by Geoffrey Hinton, Oriol Vinyals, and Jeff Dean that introduced one of the most widely known approaches to knowledge distillation.

I wanted to understand this topic because distillation helps explain how some smaller AI models learn useful behavior from much larger models. Meta used distillation while training Muse Glimmer, for example, which is a 30-billion-parameter model designed to run on a single consumer GPU.

I uploaded the paper, and AnswerThis read it and gave me an overview of what it was about.

From here, I could ask questions, inspect the cited information, create tables, and perform bibliometric analysis.

I started with a basic question:

Prompt: How does knowledge distillation work?

The AI gave me a concise answer based on the uploaded document.

Knowledge distillation uses a larger teacher model to train a smaller student model. The student is not only trained on the final answer selected by the teacher. It can also learn from the probabilities the teacher assigns to the other possible answers.

For example, imagine that a teacher model is classifying an image.

It might assign an 80% probability that the image contains a dog, 15% that it contains a wolf, and 5% that it contains a fox.

A normal hard label would only tell the student that the image is a dog. The other probabilities provide more information. They show that the teacher considers a wolf more similar to the correct answer than a fox.

The original paper calls these outputs “soft targets.” It also uses a temperature setting to make the probability distribution softer, allowing the student to learn more about the relationships between possible answers.

This does not make the student identical to the teacher. The smaller model still has less capacity. Distillation is more about transferring useful behavior into a model that is cheaper or easier to run.

I could have asked ChatGPT or Claude to explain the same concept. What I liked about AnswerThis was that the answer remained connected to the uploaded paper.

When I clicked on the reference, it brought me back to the source so I could check the relevant part of the document.

That saves time, especially when reading a long paper and trying to remember where a certain explanation came from. I do not have to search the PDF again or ask the AI to provide a source after it has already answered.

The quality of the answer still depends on how specific the question is. A broad prompt may give a broad summary, while a narrower question is more likely to point me toward the exact part of the paper I need.

After understanding the starting paper, I can look for related research.

One way to do that is through the Citation Mapper.

Select a paper, enter a topic or DOI, and generate a citation map. The map shows the papers referenced by the original study and the newer papers that cited it.

This is useful because a normal keyword search does not always show the complete development of an idea.

The title of a newer paper may not contain the words “knowledge distillation,” even if the method is important to its training process. Following the citation network can reveal later applications, improvements, criticisms, and comparisons that a simple search could miss.

Starting with the Hinton paper, for example, I could look for newer studies that applied distillation to language models, healthcare systems, multimodal models, or AI agents.

I can then save the useful papers into the same project.

AnswerThis says its literature review system searches a database of more than 300 million papers. I can also apply filters if the initial result contains too many unrelated sources.

I might limit the search to papers published after a certain year, require a minimum citation count, or focus on a particular academic source. These filters are useful, but they need to match the research question.

Using a high minimum citation count for a newly released AI technique could remove the newest papers. At the same time, removing the filter entirely might return many papers that have not received much attention or independent evaluation.

Citation count is helpful for finding influential work. It does not prove that the paper is correct.

When I’m done with the research, I can move on to writing the draft.

AnswerThis has a built-in AI Writer, so I do not need to switch to a separate platform immediately. The papers saved in the project are still available while I write.

I can create an outline, draft individual sections, add citations, improve the wording, or continue a paragraph. I prefer doing this one section at a time rather than asking the AI to write the entire article from one short prompt.

That gives me more control over which papers are used and what each section is trying to explain.

When the document is finished, AnswerThis supports exporting it as PDF, DOCX, Markdown, or LaTeX. Citations can also be formatted in thousands of academic styles or transferred to reference managers such as Zotero and Mendeley.

And that’s it.

I started with one paper, asked questions about it, checked the cited information, found related studies, saved them into a project, and used the same research while writing the draft.

Why should you care?

You might be wondering why I don’t simply use ChatGPT, Claude, Grok, or NotebookLM for all of this. I still use those tools.

ChatGPT and Claude are useful when I need help understanding a technical idea or improving an explanation. NotebookLM is great when I already have several documents and want to ask questions about them.

The problem is that research involves more than getting an answer from a chatbot.

Researchers may need to screen hundreds or even thousands of papers before writing anything. They have to check the title, abstract, research method, sample, dataset, findings, and limitations before deciding whether the paper is useful.

Doing that manually can take weeks.

AI can speed up some of this work, but inconsistent citations create another problem. A model may provide a source that exists but does not support the exact claim. It may also summarize a qualified result as if it were universally true. A citation is not a guarantee that an answer is correct.

AnswerThis itself recommends checking important citations because large language models are still involved in the final output. The benefit is that the source is already connected to the answer, making the verification easier.

I can click the citation, inspect the paper, and check whether the wording is accurate. I am still responsible for deciding whether the evidence is strong enough to use. The other problem is managing too many applications.

If the search happens in one tool, the PDF analysis in another, the references in Zotero, the notes in a document, and the writing in a chatbot, it becomes easy to lose context.

I may remember a useful finding but forget which paper it came from. I may save the same paper more than once. I may cite an abstract without realizing that the full paper gives a more limited conclusion.

AnswerThis gives me one place for the search, paper library, cited answers, research tables, and draft. I can still use other AI tools when they are better for a particular task, but the main evidence stays inside the research project.

The platform can also be used by teams.

You can invite co-authors or other researchers into a shared workspace, share a library, and work from the same collection of papers. This is better than everyone maintaining a separate folder and sending different versions of the reference list to each other.

Privacy is also a big factor.

AnswerThis says uploaded documents are not used to train its models and are not shared with other users. Its data-handling guide says uploaded documents are stored temporarily and removed periodically.

The company also says research data is encrypted at rest and in transit. Enterprise accounts include additional controls such as role-based access, project permissions, SSO, and audit logs.

I would still review the exact privacy terms before uploading regulated medical data, personal information, unpublished research, or confidential company documents. Different organizations have their own rules about where research data can be stored.

For ordinary academic and technical research, I like knowing that the platform has at least considered this problem. Many people upload documents to AI tools without checking whether those files will be stored or used for training.

Final Thoughts

AnswerThis helped me understand the knowledge-distillation paper without separating the questions, citations, related research, notes, and final draft into several different tools.

I could upload the paper, ask what a technical term means, check the section behind the answer, find newer research through the citation map, and save the useful papers into the same project.

I also appreciate that its creators put a lot of focus on information accuracy and user privacy. The tool can still make mistakes, and I would never use an AI-generated citation without checking it. But having the source connected to the answer makes that checking much easier.

Have you tried any other research-focused AI tools before? Let me know in the comments.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Picking an open-source model is the enjoyable part. The harder moment arrives when one agent needs an embedding model, a reranker, an OCR model, a safety model, and a small language model. Each one brings a container, a health check, an autoscaler, a GPU budget, and a dashboard.

That is where a model choice turns into an infrastructure project.

Subscribe now

In this article, I compare three routes for deploying open-source models to production in 2026. You can build the stack yourself with vLLM, TEI, or SGLang, use managed inference APIs, or run a multi-model server such as SIE. By the end, you’ll know which route fits a single model, a low-volume prototype, or a fleet of task-specific models.

What “Production-Ready” Actually Means

A production-ready deployment can handle traffic changes, failures, model updates, and routine debugging without constant manual intervention.

It needs autoscaling that follows demand, multi-model support for agent workflows, and sensible defaults that remove the need to tune every model by hand.

It also needs observability for latency, throughput, errors, and quality drift, plus a reproducible setup that behaves consistently on a laptop and in a production cluster.

A demo can survive with one model and one GPU. Production starts when 100 concurrent agents arrive, a worker crashes, or a model update changes latency. The infrastructure beneath the model determines whether the service recovers cleanly.

Free model weights still come with inference costs. GPU time, networking, storage, monitoring, and engineering work belong in the budget.

Why Self-Host Open-Source Models?

Teams self-host open-source models for control over data, cost, and model choice.

• Model quality on focused tasks: Research covered by MIT Sloan found that open models reached about 90% of closed-model performance at release and often caught up within months. For embeddings, reranking, classification, and extraction, a task-specific evaluation matters more than the logo on the model card.

• A different cost profile: Managed APIs are inexpensive to start, but agents can make several model calls for every user request. Self-hosting replaces that repeated usage bill with compute and operating costs. The savings depend on traffic, GPU utilization, and how much maintenance the stack needs.

• Data control: A self-hosted deployment can keep patient records, financial data, or proprietary code inside your cloud or on-premises environment. That can simplify data-residency decisions, although your team still owns the security work.

Self-hosting changes how you pay. It pays off when the workload is steady enough to use the hardware well, and the operating burden stays under control.

Three Routes to Production

The right route depends on how many models you serve, how much control you need, and who will maintain the system.

1. DIY With vLLM, TEI, or SGLang

The DIY route gives you direct control over the serving layer. vLLM and SGLang are high-throughput frameworks for large language and multimodal models. Hugging Face’s Text Embeddings Inference, or TEI, serves embedding, reranking, and sequence-classification models.

The software pricing is straightforward:

• vLLM: The Apache 2.0 software is free. You pay for GPUs, networking, storage, monitoring, and engineering time.

• TEI: The Apache 2.0 server is free. Your bill comes from the hardware and the surrounding production stack.

• SGLang: The Apache 2.0 framework is free. Infrastructure and operations are additional costs.

Complexity grows when an agent needs several model types. Each server may need its own deployment, capacity rules, health checks, and dashboards. You get maximum tuning control, but you also own every connection between the pieces.

This route fits one heavily used model or a team with strong machine-learning operations experience.

2. Managed Inference APIs

Managed inference APIs are the fastest route to a live endpoint. The provider provisions hardware, monitors it, and handles most scaling work. Your application sends a request and receives a result.

Pricing varies by provider, model, and billing unit. Hugging Face’s dedicated Inference Endpoints start at $0.033/hour for a CPU instance and $0.50/hour for a GPU instance, with usage calculated by the minute. Other providers may bill by token, request, or compute time.

The table below shows currently available GPU instances on Hugging Face and their hourly pricing.

The trade-offs are lower infrastructure control, provider-specific model catalogs, and data that leaves your environment unless the service offers a suitable private deployment. Costs can also climb quickly when one agent request triggers several model calls.

Managed APIs fit prototypes, uneven traffic, and teams that want to avoid running inference infrastructure.

3. Superlinked Inference Engine

Superlinked Inference Engine, or SIE, takes a multi-model approach. It serves more than 100 preconfigured models through one API and loads them on demand. The catalog covers search, reranking, document conversion, structured extraction, content safety, vision, and generation.

The self-hosted version is Apache 2.0 software, so you pay for your own cloud resources. SIE Cloud uses task-based usage pricing. Current examples include $6 per 1 billion tokens for e5 embeddings, $10 per 1 billion tokens for a bge reranker, $0.20 per 1,000 pages for Docling, and $90 per 1 billion input and output tokens for Qwen3–4B generation.

SIE also ships the surrounding production components, including a load-balancing gateway, KEDA autoscaling, Grafana dashboards, and Terraform modules for AWS, Google Cloud, and Azure. Its cluster-wide queue is designed to pack mixed requests efficiently across shared GPUs.

This route fits agents that call several task-specific models and teams that want to keep the data and infrastructure in their own cloud.

Quick Comparison

Use this table to match each route to the operating model you already have.

DIY deployment requires the most setup and charges for GPU and runtime costs, but keeps data in your cloud and gives you full control.

Managed APIs are easier to start with, billing by tokens, requests, or compute, while the provider handles operations.

SIE sits between the two, offering free self-hosting or managed usage pricing, support for more than 100 models, and built-in gateway, autoscaling, dashboards, and Terraform modules.

In short, DIY fits one carefully tuned model, managed APIs suit prototypes and uneven traffic, and SIE is designed for teams running a fleet of task-specific models while retaining cloud and data control.

Deploying With SIE

SIE exposes four primitives that cover the common small-model workflow:

• Encode: Turn text, images, or documents into dense, sparse, or multi-vector representations that software can compare.

• Score: Rerank a shortlist so the most relevant results rise to the top.

• Extract: Pull structured data or named entities from messy text and documents.

• Generate: Run an open language model for the agent loop or another text-generation step.

The practical sequence is short:

1. Run SIE locally on Apple Silicon or an NVIDIA GPU and connect one task through the SDK.

2. Test the chosen model against your own data, latency target, and expected request volume.

3. Move the same model IDs and application code to a production cluster.

4. Add autoscaling limits, dashboards, alerts, and a rollback plan before opening the endpoint to traffic.

The SIE quickstart covers local setup, and the deployment guide provides Terraform and Helm options for the major cloud platforms. The same stack can also stay fully self-hosted, which keeps the production path close to the local one.

Final Thoughts

The easiest production path depends on the shape of the workload. Managed APIs win when speed and low operational effort matter most. vLLM or SGLang makes sense when one large model needs close tuning. TEI is a focused choice for embeddings and reranking.

SIE is the strongest fit in this comparison for an agent that depends on a mixed fleet of task-specific models. It reduces the number of production systems you need to assemble while preserving self-hosting and cloud control.

In 2026, the practical architecture is the one that lets the model count grow without making the operations stack grow at the same rate.

Frequently Asked Questions

What is the easiest way to deploy open-source models to production in 2026?

The easiest route is a managed endpoint for one or two models. For an agent that uses several task-specific models, a multi-model server with routing, autoscaling, and monitoring removes more of the production work.

Is SIE a replacement for vLLM or SGLang?

No. vLLM and SGLang are strong serving engines for large generative models. SIE can use SGLang as a backend and focuses on running the broader collection of models around an agent through one production stack.

Are open-source models good enough for production?

Yes, open-source models can be strong production choices for embeddings, reranking, classification, extraction, vision, and many generation tasks. Evaluate each candidate on your own data because benchmark leaders don’t always match the latency, accuracy, or hardware limits of your application.

Does self-hosting save money?

Yes, self-hosting can save money when traffic is high, and the hardware stays well used. It can cost more at low volume because you still pay for idle capacity, monitoring, maintenance, and engineering time.

Can I try SIE without an NVIDIA GPU?

Yes. SIE runs locally on Apple Silicon and NVIDIA GPUs. The managed cloud option also lets you test the API without operating your own hardware.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Seedance 2.0 has dominated the AI video space over the past couple of weeks. Its realism quickly went viral, along with its ability to recreate famous people and copyrighted characters. That also made the model controversial, drawing criticism from Hollywood groups and actors’ unions over copyright and consent concerns.

Now, S…

Read more

If you’ve been using LoRAs to give your AI images a custom character or style, you know how annoying it is when the output barely changes. When your LoRA isn’t working, you add it, hit Generate, and stare at the result wondering whether it did anything at all.

Subscribe now

A LoRA, short for Low-Rank Adaptation, is …

Read more

Despite the advancements and power of today’s image models, there are still days when I get contextually incorrect results. For example, I asked for an anime girl with short silver hair, green eyes, and a red scarf. The model gave her long brown hair and removed the scarf instead. I added more deta…

Read more