Moonshot AI released Kimi K3 in mid-July, selling it as a serious professional coding tool that competes head-on with Claude and GPT, at a lower price. It’s a 2.8-trillion-parameter open-weight model, the largest ever out of China. The company says it rivals Anthropic’s Opus 4.8.

The Kimi K3 API runs $3 per million input tokens and $15 per million output. Anthropic’s top model, Fable 5, costs $10 per million input tokens and $50 per million output. That’s more than three times the price for both input and output.

A model that costs a third as much is only a good deal if the output and user experience meet current expectations. To find out where Kimi K3 stands against the professional tools it’s chasing, I gave Kimi K3 and Fable 5 the same three real coding jobs and tracked every token.

See also: Kimi K3 tops Arena’s coding leaderboard — and it’s open-weight

The tests

I used fd, the Rust file-finder from sharkdp. fd is a fast, friendlier replacement for the Unix find command. I chose it because it is real production Rust with a deep, documented bug history to pull from.

Kimi K3 is not available in coding tools like Cursor yet, so I completed the three tests using native CLIs. I ran Kimi K3 inside Moonshot’s new Kimi Code terminal agent (version 0.27.0), and Fable 5 inside Claude Code (version 2.1.212). I used identical prompts, so the model and CLIs were the only variables. I built a new folder for each test on each model (six total), so each test was standalone.

Here are the three tests I ran (in this order): 

• a bug fix
• a multi-file refactor
• a feature build

For every test, I recorded time (using a stopwatch), tokens, and cost from Cursor’s usage dashboard.

Earlier this week, I ran Grok 4.5 against Claude Opus 4.8 on the same three tasks in the same repo using identical prompts, which you can read here [add link]. Since all four models ran the same tests, you could consider this pair of articles Fable vs Kimi vs Opus vs Grok.

Setting up Kimi

This was a very easy setup. The Kimi Code CLI installed with one curl command, and the account setup was simple. There was one hiccup, though. My test command of “say hello” hung for a few minutes without a reply or an error message. The cause showed up later as a 429 error. My brand-new API account had no balance, and Kimi won’t respond until you add a card and top up. The nice surprise was that once I recharged, Moonshot gave me a $5 signup voucher, so new accounts do get some free credit.

Moonshot AI’s Kimi K3 matched Anthropic’s Fable 5 line for line on three real coding tasks and cost a third as much… but took four times as long to do it.

(I couldn’t write this post without saying the one thing that’s been on my mind during the test. The name Kimi K kept putting Kim Kardashian in my head. I never think about Kim Kardashian. I have now thought about her for two days straight.)

Test 1: The bug fix

The prompt:

There is a bug in this codebase (the fd command-line tool). When you pass the –no-ignore-vcs flag, fd also stops respecting ignore files in parent directories. It should not do that. Find the root cause and fix it so –no-ignore-vcs no longer disables parent-directory ignore files. Do not change any other behavior.

I checked out fd at the commit right before the real 2021 fix for this bug (issue #907) and wiped the git history so neither model could look up the maintainers’ answer. Both models found the root cause and removed the same single line from src/main.rs. The diffs were byte-for-byte identical. Four models, four identical diffs. All 70 tests passed for both.

The difference came down to numbers. Fable finished in 1 minute 4 seconds on about 347K tokens and cost $0.85. Kimi took 3 minutes 7 seconds on 238K tokens and cost six cents. K3’s bug test was the lowest cost but highest time I’ve seen on this test.

Test 2: The refactor

The prompt:

In src/main.rs, the construct_config function is large and does most of its work inline. Refactor it to improve readability and structure: move it, along with any helper logic it needs, into a dedicated new module (for example src/config_builder.rs), and break the work into smaller focused functions. Do not change any behavior. Every existing test must still pass, and the CLI must behave exactly the same.

Both models did the same thing: a new config_builder.rs module, the big function split into focused helpers, all 264 tests green, diffs within a few dozen lines of each other in size.

The results were the same, but the engineering process wasn’t. Kimi was the more thorough engineer. It snapshotted the old binary before touching anything, then diffed the old and new binaries across roughly 40 CLI scenarios to prove behavior had not changed.

But this came at the cost of efficient time. It took 14 minutes 50 seconds on 928K tokens, the slowest run of any model on any test I’ve run in the last few months. Fable did the same refactor in 3 minutes 11 seconds on about 639K tokens. Kimi cost $0.70, Fable $2.32.

This tells a similar story to the last test. Same results, lower cost, longer time.

Test 3: The feature build

The prompt:

Add a new –count flag to fd (the command-line file finder). When –count is passed, fd should not print the matching paths. Instead, it prints a single line: the total number of entries that matched, respecting all the usual filters (so for example “fd –count –extension rs” prints how many .rs files matched). Add the flag to the CLI, wire it through the search and output path, and make sure all existing behavior and tests still pass.

Both delivered a correct, working --count flag. Kimi touched six files and updated the man page. Fable touched seven and went one step further, updating the zsh shell completions too. Fable miscounted the test environment twice while writing its own test, guessed 13, then 10, then landed on 11, but it caught and fixed itself both times without my help.

Kimi took almost 5x longer than Fable to deliver the --count flag. Their times, tokens, and costs were 10 minutes 21 seconds, 2.1 million tokens, $1.38, and 2 minutes 34 seconds, about 1.46 million tokens, $2.81, respectively.

The results

Across the three jobs, Kimi cost $2.13 to Fable’s $5.98, almost exactly a third of the price that Moonshot’s rates promise. But the discount comes from the discounted rates alone. Kimi used more tokens than Fable, 3.3 million to 2.4 million. Then there’s the time cost. Fable finished all three jobs in under 7 minutes. Kimi needed just over 28. I run different tests on models weekly, and this was by far the longest time I’ve seen.

So what do I really think about Kimi? The results are solid, but this is a crowded market with established frontrunners. We’re still in the AI freemium era, so lower costs matter, just not nearly as much as speed. Kimi will need to match the speeds of the other models to compete, which means cutting its time by 5x in some cases. 

It’s also worth remembering we’re in the land of done is better than perfect. This is the first public iteration of K3, and it will change.

I don’t see a place for it in the current landscape, but I’m interested in watching it improve over the next few months. Will it speed up enough to earn its seat at the table? I look forward to Moonshot’s next batch of updates so we can benchmark again and find out.

The post Claude Fable 5 vs. Kimi K3: Same results, one-third the cost, 4x slower appeared first on The New Stack.

TL;DR: Keep only the benchmarks that protect important hot paths. Use baseline/diff comparisons to catch regressions, but do not trust noisy shared runners blindly. Performance regression testing needs stable machines, clear thresholds, and restraint.

After a successful performance investigation, the benchmark folder looks valuable.

It contains the history of the work: experiments, false starts, before-and-after comparisons, warmup cases, exception cases, and small probes that helped explain the code. Keeping all of it feels safe, and deleting any of it feels strangely reckless.

That instinct leaves the team maintaining experiments long after they have answered their questions.

Benchmarks have a maintenance cost. They take time to run, understand, and fix when the production code changes. The useful measure is whether the suite protects important performance promises, not how many benchmark classes survive in the repository.

Most benchmark experiments should expire

Many benchmarks are investigation tools. They help answer a question during the improve-and-compare loop. Once the question is answered, the benchmark may no longer deserve permanent continuous integration time.

Keep the benchmarks that protect core hot paths. In the NServiceBus pipeline case, a benchmark for pipeline invocation can make sense because every message goes through that path. A regression there can affect many users across many transports.

Protecting that benchmark is worth the maintenance cost.

A one-off benchmark that tested an abandoned idea is different. Keep the lesson, not necessarily the code. Move the finding into the pull request, a decision record, or a short note near the optimized code. Future readers need to know why the code looks the way it does. They do not need every experiment to run forever.

• Keep benchmarks for shared infrastructure hot paths.
• Keep benchmarks that protect public contracts or expensive operations.
• Delete or archive one-off experiments after the lesson is captured.
• Document what was measured, what changed, and why the trade-off was accepted.

Catch regressions by comparing benchmark history

Performance regression testing usually compares two versions of the same benchmark. Run the benchmark at a known baseline commit. Store the artifacts. Move to the candidate commit or branch. Run the same benchmark again. Compare the results with a threshold.

The .NET performance repository includes a ResultComparer tool that can compare BenchmarkDotNet artifacts. The exact commands depend on your repository layout, but the workflow looks like this:

git checkout baseline-sha

dotnet run -c Release --artifacts "C:\results\before"

git checkout candidate-sha

dotnet run -c Release --artifacts "C:\results\after"

dotnet run --project C:\Projects\performance\src\tools\ResultsComparer \
  --base "C:\results\before" \
  --diff "C:\results\after" \
  --threshold 2%

The threshold is policy. Two percent might be reasonable for one benchmark and meaningless for another. Choose the threshold based on observed variance and business impact, not because the number looks tidy.

Thresholds are policy, not math magic

A benchmark result is a distribution, not a single truth. The same code can produce slightly different measurements from run to run. The machine, operating system, runtime, background processes, CPU frequency, temperature, and neighboring workloads all get a vote.

Before turning a benchmark into a failing gate, learn its natural variance on the machine that will run it. If a benchmark moves by three percent when nothing changed, a two percent regression threshold will create noise. The team will learn to ignore it, and then the gate has failed socially even if it works technically.

CPU-bound benchmarks are often more stable than memory-bound or disk-bound benchmarks, but stability is not guaranteed.

Measure the variance before deciding what the gate should enforce.

Shared runners can lie to you

Shared continuous integration runners are convenient. They are also shared. Another build on the same host can affect your measurements. The hardware can differ between runs. Power settings and virtualization layers can change the timing profile. That is the noisy-neighbor problem.

Two subsequent builds on the same revision can have ranges of 1.5..2 seconds and 12..36 seconds. CPU-bound benchmarks are much more stable than Memory/Disk-bound benchmarks, but the “average” performance levels still can be up to three times different across builds.

Andrey Akinshin, quoted in the BeyondSimpleBenchmarks talk material

That does not mean shared runners are useless. They can still compile benchmarks, run smoke checks, or provide a rough signal. But a flaky performance gate is worse than no gate.

Developers learn to rerun jobs until they pass, and performance work starts to feel like superstition. Eventually the team assumes every benchmark failure is noise.

Performance culture is social as much as technical. If people stop trusting the signal, the tooling has already lost.

Use stable hardware when the gate matters

If the benchmark is important enough to block a pull request, the machine should be stable enough to support that decision. That may mean a dedicated bare-metal runner, a controlled virtual machine, a lab machine, or a manually triggered benchmark pipeline for risky changes.

Not every team needs a performance lab. A team that is just starting can run benchmark experiments locally, review the results manually, and build shared knowledge. That is already progress. Automating noisy benchmarks too early can create more frustration than value.

Running every benchmark on every pull request is automation, but it is not necessarily maturity.

A mature team knows which performance promises are stable and important enough to defend automatically.

Regression tests still need human judgment

A regression is not always a bug. Sometimes a slower implementation fixes correctness, improves security, removes a dangerous shortcut, or makes the system easier to maintain. The benchmark should start a conversation, not replace one.

When a benchmark fails, ask what changed. Did the hot path slow down because of accidental allocations? Did a new feature add necessary work? Did the benchmark become invalid because the production code changed shape? Did the machine have a bad run?

The best performance gates make accidental regressions cheap to catch and intentional trade-offs explicit. They should not make teams afraid to improve the design.

Close the loop with continuous improvement

The full performance loop is still the foundation: profile with a profiling harness, improve a hot path, benchmark and compare, profile again, ship, and observe production. Regression testing is a maturity step that protects the gains after the team knows what matters.

This approach also pushes against rewrite culture. It is easy to look at old code and say, “This is slow. We should rewrite it.” Sometimes a rewrite is right. Most of the time, the team needs more knowledge first.

Otherwise, the rewrite repeats the old mistakes with newer code and better formatting.

Profiling and benchmarking build the missing knowledge. They show which paths matter, which assumptions were wrong, and which trade-offs paid off. After a few loops, the team may not need a rewrite. If it still does, the rewrite starts with evidence instead of frustration.

Performance knowledge accumulates. A small improvement can expose the next bottleneck, a useful benchmark protects the path, and production observations correct assumptions made in the lab. The team gradually has less reason to guess.

Start with one hot path and build a profiling harness around it. Take memory and CPU profiles, improve one thing, benchmark it, and profile again. Then write down what you learned.

The profile points at the work and the benchmark tests the change. Production then exposes whatever the lab missed.

Repeated often enough, this becomes ordinary engineering work rather than a rescue mission after performance has already collapsed.

Further reading

• .NET ResultComparer
• Preventing regressions in the .NET runtime benchmarking workflow
• Andrey Akinshin on GitHub Actions performance stability
• BeyondSimpleBenchmarks repository

Common questions

Should performance benchmarks run on every pull request?

Only if the benchmark is stable, fast enough, and important enough. Otherwise, run it on demand, nightly, before release, or when a change touches the protected hot path.

What should I do if continuous integration results are noisy?

Measure variance, loosen or remove the gate, use dedicated hardware, or treat the result as a signal rather than an automatic failure. Do not keep a flaky performance gate just because it feels rigorous.

How many benchmarks should a team keep?

Keep the benchmarks that protect meaningful performance promises. If nobody can explain what decision a benchmark supports, it probably does not belong in the permanent suite.

Performance loop status

• [x] Understand the loop
• [x] Build profiling harness
• [x] Profile
• [x] Improve / Benchmark
• [x] Profile again / Ship and observe
• [x] Protect the gains

TL;DR What’s the best Angular grid? For most enterprise Angular applications, Progress Kendo UI for Angular Grid is the strongest all-around choice. It combines high-performance data handling, virtualization, AI-assisted features, theming tools and integration with a broader UI component library.

On the internet, data is everything. Since the beginning of the web, showing lists has been the standard way to present information.

We started with simple HTML tables, but over the years, displaying data has become much more than just creating a list. Today, it involves complex interactions and the need for data to travel smoothly between many different components.

In any application, when a list is slow or difficult to use, it is not just a small problem. It is a major blocker. A grid that cannot handle real-time updates does more than frustrate users; it can cause serious business problems and angry users.

In 2026, choosing a grid component is a business decision, not just a technical one. Modern grids must handle thousands of rows, update every second, export data for reports, integrate with AI agents and look good on all screens. You need all of this without making your developers write thousands of lines of custom code.

To understand why this matters, the best way is with a real-world scenario.

The Scenario

You have been hired by a startup to build a trading dashboard with real-time market data, thousands of rows updating constantly, complex filters, frozen columns, and one-click export to Excel. The CTO wants a working minimum viable product (MVP) ASAP to compete with time-to-market.

In this situation, your grid is the most important part of the product. Every second of lag or every missing feature is a threat to your deadline. If the grid fails during a demo with investors, the rest of the app does not matter.

Consider: Many teams waste half their time building basic features like virtual scrolling. However, the biggest problem is communication. A grid must talk to the rest of your app. When you mix different libraries for your grid and your buttons, making them work together is a nightmare.

Let’s look at the best options available today and see how they can help you and your team.

1. Kendo UI for Angular Grid

No matter how small, large or complex your data is, the Progress Kendo UI for Angular Grid is the best choice when you need a grid that meets every requirement. It is built to handle everything from simple lists to massive enterprise datasets with real-time updates.

This component is not just powerful; it is also easy to customize. Because it is part of a complete suite, the grid integrates perfectly with other Kendo UI components like charts and dropdowns. This solves the “headache” of making different parts of your app talk to each other.

I have watched how building grids has evolved over many years. Based on that experience, here are the reasons why Kendo UI is the right choice for professional projects:

Why Kendo UI Grid is the Right Choice for Professional Projects

• Smart Grid and AI Assistant: This is where Kendo UI really changes the game. It is not just a table; it is a “smart” component. With the AI Smart Box, users can use natural language to search, filter and manage data. Instead of looking for exact keywords, the Semantic Search understands what the user actually wants.

• AI-powered insights: The grid can highlight important rows and provide smart data summaries automatically. This helps users find the most important information without manual work.

• Virtual scrolling and row virtualization: The grid handles hundreds of thousands of rows easily. Scrolling is fast even when data changes constantly, which is essential for trading.

• Real-time data binding: It works excellently with live data streams. You can update the grid without refreshing the entire dataset, keeping the UI fast.

• Frozen columns and column management: You can pin important columns while users scroll horizontally through large datasets.

• Built-in Excel and PDF export: This is a native feature, not a third-party plugin. It keeps your styles, filters and column settings.

• MCP Server: The Kendo UI MCP Server helps AI tools (like Cursor or Copilot) write better code by providing the correct patterns for the component.

• ThemeBuilder: You can import Figma design tokens to make the grid match your brand perfectly without writing complex CSS.

• Expert support: If you have a problem during a busy week, you can get help directly from the engineers who built the grid.

Pro tip: You can try the Kendo UI for Angular Grid for free for 30 days. Test it with your real data before you decide.

If you have always worked within the official Angular ecosystem, the next option on this list will be very familiar to you.

2. Angular Material Table (CDK)

Angular Material is the official UI library from the Angular team. Most Angular developers have used its table component.

• The Good: It is very stable, updated frequently and follows Material Design standards. The Component Dev Kit (CDK) gives you a lot of flexibility.

• The Cons: You must build almost every feature yourself. Sorting, filtering, virtual scrolling and export are not included by default. For a project with a short deadline, this is too much work.

• My Feedback: Angular Material is a good starting point, but it is only a foundation. In a high-stakes project, you should not waste time building features that professional libraries have already solved.

When you need a tool that focuses entirely on high-performance tables as a standalone component, you will likely look at the following library.

3. AG Grid

AG Grid is a very popular standalone grid library. It is known for high performance and many enterprise features.

• The Good: If your app is mostly about tables, AG Grid is very fast. The community version includes many features for free.

• The Cons: A real application needs more than just a grid. You will also need charts, date pickers and modals. AG Grid does not provide these. If you mix it with other libraries, it is difficult to keep the design and styling consistent.

• My Feedback: AG Grid is powerful, but it is a standalone tool. Kendo UI gives you the same power within a unified system. This means your grid, charts and dropdowns all use the same design and the same support team.

For teams that prefer a large collection of components that are easy to implement, there is another very common choice in the community.

4. PrimeNG

PrimeNG is a very complete library. Its p-table component is good for most standard use cases.

• The Good: It has good documentation and is easy to start using. It works well for standard CRUD applications with medium-sized datasets.

• The Cons: For extreme scenarios, such as thousands of real-time updates, it can have performance issues. Virtual scrolling is available but requires more manual configuration.

• My Feedback: PrimeNG is a good choice for standard business apps. But for a fintech dashboard where the grid is the main product, you need a tool built for high performance from the start.

As your project moves into the enterprise space with specific corporate requirements, you might consider an alternative that is widely used in large companies.

5. Syncfusion Angular Grid

Syncfusion offers an enterprise grid with many features like row grouping and PDF export.

• The Good: It has a long list of features and handles large data well. It integrates well if you already use other Syncfusion tools.

• The Cons: The API does not always feel like standard Angular code, so there is a learning curve. Changing the design to match a Figma file can be difficult and slow.

• My Feedback: If your designers and developers need to work together daily, the difficulty in styling Syncfusion can be a problem. Progress ThemeBuilder makes this process much faster and more accurate in Kendo UI.

Teams coming from a background in traditional software development often find that the next grid fits their existing mental model perfectly.

6. DevExtreme Angular DataGrid

DevExtreme by DevExpress is a feature-rich grid often used in traditional enterprise software.

• The Good: It is great for complex scenarios like master-detail views and multi-level grouping. It will feel familiar if your team has a background in .NET or WinForms.

• The Cons: Some of the patterns feel old for modern web development. Customizing the CSS to look modern can be a difficult task.

• My Feedback: Modern applications need to be fast and look current. DevExtreme’s older patterns can slow down a team. The Kendo UI library uses a modern, Angular-native architecture that is easier to maintain.

If your main priority is fast data visualization and specialized charts, there is a competitor that focuses heavily on those areas.

7. Ignite UI for Angular Grid

Ignite UI focuses on data visualization and high-performance grids.

• The Good: The rendering engine is very fast and handles live updates well.

• The Cons: The community is smaller than other options. If you find a complex bug, it is harder to find answers or documentation.

• My Feedback: Performance is important, but support is also critical. The Kendo UI Grid offers similar performance but adds better documentation and a larger community to help you when you have problems.

For developers who value a very clean design and a modular architecture based on modern TypeScript principles, there is an elegant solution to consider.

8. Taiga UI Table

Taiga UI is a modular library with a focus on TypeScript.

• The Good: It has a very clean design. Because it is modular, you only use the code you need.

• The Cons: You have to build many features yourself. Virtual scrolling and export are not ready to use out of the box.

• My Feedback: Taiga UI is a great project, but it requires too much manual work for a short deadline. The Kendo UI library gives you 120+ components that are already tested and ready to use.

Some projects still use libraries that were very popular during the early versions of Angular and remain in many existing codebases.

9. ng2-smart-table

ng2-smart-table was a very popular choice in the early days of Angular.

• The Good: It is very simple to set up for basic tasks like sorting and filtering.

• The Cons: The library is not updated frequently anymore. This creates a risk of bugs or compatibility issues with new versions of Angular.

• My Feedback: Using a library that is no longer maintained creates “technical debt.” The Kendo UI library is supported by Progress Software, which means it receives regular updates and a clear roadmap you can trust.

Finally, if your application requires a grid that behaves exactly like a spreadsheet instead of a standard list, there is a specialized tool for that specific case.

10. Handsontable

Handsontable provides a spreadsheet-like experience (like Excel) in the browser.

• The Good: It is the best choice if your users need to edit data like a spreadsheet (bulk edits, formulas, etc.).

• The Cons: The grid does not fully support Angular, works like a wrapper and is very limited (it also has a separate commercial license for bringing in Excel formulas features).

• My Feedback: Handsontable is perfect for spreadsheets, but a trading dashboard has different needs. The Kendo UI Grid provides the necessary Excel features while offering native Angular integration and real-time performance.

Summary

Today we learned how many good Angular grids exist, but when developers or agents in 2026 need to cover all the needs for your team and project, the list of options becomes much shorter. Mst grids on this list are good at one specific thing. However, for a project where the grid is the core of the product, you need a complete solution.

I pick the Kendo UI for Angular Grid as the best choice because it combines performance, features and design flexibility, and is also ready for the AI era with tools like the MCP Server.

When you have a short deadline, you need a tool that helps you work faster from day one and keeps the focus on building your product.

As I mentioned, Kendo UI for Angular comes with a free 30-day trial. So go ahead and poke around:

Download Free Trial