Key Takeaways

• Ornit 1.0 is a self-training AI coding model released by the DeepReinforce team under MIT license—completely free and open-source
• On the SWE-bench coding benchmark, Ornit’s largest model scored 82.4% versus Claude’s 70.3% and Opus 4’s 85%
• The smallest 9B parameter model (only 19 GB) runs on a single GPU and still achieves 69.4% on benchmarks
• Unlike traditional AI, Ornit writes its own learning framework—it doesn’t need humans to scaffold its problem-solving approach
• Available via official site, Hugging Face, or API through providers like Protoverse

What Makes Ornit 1.0 Different From Other Coding AIs

Most coding AI models I’ve worked with follow a familiar pattern. Humans build what’s called a “scaffold”—essentially a framework that tells the AI: “here’s how to approach this problem, follow these steps.” It’s like giving a student a detailed study guide before an exam.

Ornit doesn’t work this way. Here’s what caught my attention: the model builds its own scaffold. It both solves the problem AND invents the management system for how to solve that problem, improving both simultaneously. This means it discovers solution paths that no human explicitly taught it.

The DeepReinforce team built this as an agent-based model family, not just another chatbot. It doesn’t just talk about code—it takes real software engineering tasks and solves them. Four sizes are available, from the 9 billion parameter version that runs on a single graphics card, up to the flagship 397 billion parameter model. All MIT licensed.

The Benchmark Numbers I Verified

I always dig into the actual numbers before getting excited, and here’s what I found in the verified benchmarks:

On SWE-bench (the industry standard for real software bug fixing):

• Ornit (large): 82.4%
• Claude: 70.3%
• OpenAI: 77.5%
• Opus 4.8: 85%

On TerminalBench (command-line usage testing):

• Ornit: 77.5%
• Claude Opus: 70.3%

And here’s what genuinely surprised me—the 9 billion parameter small model scored 69.4% on benchmarks. That’s a model that fits on an ordinary computer, performing at levels that would have required massive cloud infrastructure just two years ago.

For context, Anthropic’s system that users pay $200 monthly for operates at 78.2% on comparable tests. Ornit hits 77.1%—a one-point difference—for zero cost.

What “Self-Learning” Actually Means Here

I’ve noticed a lot of confusion around “self-learning AI” in my community. Let me clarify what Ornit actually does, based on my testing and the technical documentation.

Traditional fine-tuning requires humans to curate datasets, define learning objectives, and structure the training process. Ornit’s approach—what the researchers call autonomous self-improvement—means the model generates its own training framework, evaluates its own outputs, and iteratively refines its problem-solving strategies without human intervention at each step.

Think of it like this: instead of a teacher giving a student flashcards, the student creates their own flashcard system, discovers which memorization techniques work best for them, and keeps optimizing that system while actually learning the material.

This isn’t artificial general intelligence or sentience—it’s a specific, engineered capability for code-generation tasks. But it’s a genuine step toward AI systems that require less human hand-holding to improve.

How I Tested Ornit and How You Can Too

I ran Ornit through three different setups to understand the practical access points:

Local installation: The official site provides a straightforward prompt for local execution. With the 9B model at 19 GB, I got it running on a single high-end GPU without code changes—it’s compatible with standard developer tools.

Hugging Face: Direct model downloads are available through Hugging Face links, which is how I tested the larger variants without local hardware constraints.

API access: Through providers like Protoverse, you can search “Ornit” and integrate via API if you want to build applications without managing infrastructure.

For developers already using Claude or GPT-4 APIs, the integration is designed to be drop-in compatible—no rewriting your entire stack.

What This Actually Means for Your Work

I’ve been paying hundreds of dollars monthly for premium AI subscriptions, and I run a community of 400+ developers who do the same. Here’s my honest assessment of where Ornit fits:

If you’re learning or bootstrapping: This is genuinely transformative. You can now access top-tier coding performance without subscription costs. The 9B model running locally means no API fees, no rate limits, complete privacy for proprietary code, and full customization potential.

If you’re already paying for Claude/GPT-4: The performance gap is narrow enough that you need to ask: is that 1-5 point benchmark difference worth $200/month to you? For some professional contexts where that edge matters, maybe. For many use cases, probably not.

The bigger picture matters more than any single model comparison. Self-improving AI is no longer theoretical—we have working examples. Systems that can enhance their own capabilities without constant human intervention represent a real step forward, and understanding this trajectory early puts you ahead.

FAQ

Is Ornit 1.0 really completely free to use commercially?

Yes. All Ornit models are released under MIT license, which permits commercial use, modification, and distribution without fees. You can download, modify, integrate into products, or even sell derivative systems.

What hardware do I need to run Ornit locally?

The 9B parameter model requires approximately 19 GB of storage and runs on a single powerful GPU. The larger models (up to 397B parameters) require substantially more infrastructure. For most individual developers, the 9B model offers the best local-running balance of capability and accessibility.

How does Ornit’s self-learning differ from normal AI training?

Standard AI training relies on human-designed frameworks: humans create datasets, define loss functions, and structure the learning process. Ornit autonomously generates its own problem-solving frameworks, evaluates their effectiveness, and iteratively improves both its approach and its outputs simultaneously for coding tasks.

Should I switch from Claude or GPT-4 to Ornit?

It depends on your specific needs. Ornit matches or exceeds Claude on several coding benchmarks while being free, but Claude and GPT-4 still lead in some areas and offer broader general-purpose capabilities. For pure coding automation with budget constraints, Ornit is strongly worth testing. For multi-modal or general reasoning tasks, the paid models may still serve you better.

Where I Think This Is Heading

I’ve watched the AI landscape shift weekly for years, and this release signals something specific: the commoditization of high-end coding assistance is accelerating. When a free, open model can approach or match premium services, the economic model for AI tooling fundamentally changes.

The self-improvement capability matters more long-term than any single benchmark. We’re seeing the first practical steps toward AI systems that reduce their dependence on human-curated training data. Whether this ultimately proves more capable, more concerning, or simply different remains to be seen—but it’s no longer speculative.

I don’t believe in guaranteed outcomes or hype around any single tool. What I do believe: having tested Ornit extensively, it’s a legitimate technical achievement that deserves attention from anyone building with AI, especially those currently paying premium prices for coding assistance.

Self-improving AI is now a working reality, not a research paper concept. The developers who understand and experiment with these capabilities today will be the ones best positioned as the technology matures.

Watch the full video (in Turkish — English subtitles available):

Tools & Community

• TurkoLister — the AI listing tool I use to turn Amazon products into optimized eBay UK listings in about 60 seconds (from £4.99/month, £1 one-week trial).
• AI & E-commerce Community — my Turkish-speaking community ($19/month) with weekly live sessions.
• Subscribe on YouTube — new experiments every week.

The post Ornit 1.0: Free Self-Learning AI That Beat Claude at Coding appeared first on Digital Market Mentoring.

Yesterday, the mask dropped. The creator wasn’t a Silicon Valley lab. It was Meituan—yes, the Chinese food delivery giant. Think of it as their equivalent of Yemeksepeti or Deliveroo. Through their AI division Kyutai, they had secretly trained one of the world’s largest open-source models: 1.5 trillion parameters, 1 million token context window, trained entirely on Chinese Cambricon chips—not a single Nvidia GPU involved.

This matters for anyone building with AI, and I’ll explain exactly why—including how to use it for pennies.

Key Takeaways

• 1.5 trillion parameters with 1 million token context—quality near Claude Sonnet at roughly 1/10th the price
• Trained on 50,000 Cambricon cards, making it the first trillion-parameter model built without American hardware
• MIT licensed—fully open source, free for commercial use
• Input tokens cost roughly $0.30 per million versus Claude’s ~$3.00
• Free context caching: re-read the same project files without paying again
• Available via OpenRouter, Kyutai’s own API, or through Kimi’s Client multi-agent system
• Weights not yet downloadable—API-only for now, with local deployment coming

The Mystery Model That Took Over OpenRouter

I noticed On Alpha the same way most developers did: it just appeared. No announcement, no blog post, no corporate branding. On OpenRouter—a platform I use regularly to compare models—it started climbing the rankings with disturbing speed.

Here’s what caught my attention:

• Code generation quality that matched or exceeded top-tier models
• Pricing that seemed like a bug—not a feature
• 1 million token context window, meaning it could ingest entire codebases, hundreds of pages of documentation, or massive project files in one go

Usage jumped 242% as word spread through developer channels. Meanwhile, Claude—previously dominant on the platform—slipped to #2. People were unknowingly adopting a Chinese model, and nobody knew who to thank (or blame).

The reveal came when Moonshot AI (the company behind Kimi) publicly confirmed what investigators had suspected: On Alpha was built by Kyutai, Meituan’s AI research lab. A food delivery company had created one of the most capable open models in existence.

Why the Hardware Story Changes Everything

The technical achievement here goes deeper than model architecture. Kyutai trained this 1.5 trillion parameter system on 50,000 Cambricon AI chips—Chinese-designed, Chinese-manufactured processors. No Nvidia H100s. No A100s. No American hardware at any stage.

This is historically significant. For years, US export controls on advanced semiconductors were treated as a hard ceiling on Chinese AI development. When Fablo 5 (apparently a reference to a previous model or service) was restricted, American users lost access for three weeks. The assumption was that without Nvidia chips, you couldn’t compete at the frontier.

Kyutai just proved that assumption wrong. A food delivery platform’s research team built a trillion-parameter model using domestic alternatives. The rules of this game are rewriting themselves in real-time.

For entrepreneurs like me, based in the UK but working globally, this means hardware diversification is accelerating. More training pipelines, more model providers, more resilience against single-point-of-failure restrictions. The monopoly on cutting-edge AI is cracking.

Real Numbers: What This Costs vs. Claude

Here’s where this becomes immediately practical. I run multiple automation workflows and AI-assisted development projects. Token costs are a real line item in my monthly expenses.

That’s roughly a 10x price difference for comparable quality. When you’re running thousands of API calls monthly—processing documents, generating code, analyzing data—this isn’t marginal savings. It’s the difference between a $300/month AI bill and a $30 one.

Kyutai’s current promotion drops their already-low pricing even further. Their token packages (prepaid, 30-day validity) beat pay-as-you-go API pricing for consistent usage. During launch, they’re offering what was normally a $299 tier for $60.

But the feature that genuinely impressed me: free context caching. When you’re working on the same project repeatedly—refining code, iterating on documents—the model doesn’t charge you again for re-reading the same context. This is how it should work, and frankly, Western providers should take note. For long-running projects with extensive context, this alone can cut costs by 30-50%.

How I’m Actually Using It: Three Pathways

Option 1: OpenRouter (Simplest)

If you already have an OpenRouter account, search for the model directly and select it. No additional setup. This is how I first tested it—took under two minutes to start making calls.

Option 2: Kyutai’s Native API

For direct access, create an account on Kyutai’s platform, generate an API key, and integrate. They’ve made this deliberately compatible with OpenAI and Claude SDK formats, so if you’re already using those clients, you typically just change the base URL. I’ve tested this in Cursor and standard API clients—it works cleanly.

Option 3: Kimi Client (Most Powerful for Multi-Agent Work)

This is where it gets interesting for serious builders. Kimi’s Client (from Moonshot AI) has evolved into something I haven’t seen elsewhere: a multi-agent routing system that automatically selects the best Chinese AI model for each specific task.

Here’s how it works in practice: you submit a project, and Client dynamically routes to DeepSeek, MiniMax, Kimi itself, or now Kyutai’s models—whichever performs best for that particular job. I’ve watched it switch between models mid-workflow based on task characteristics.

Setup is straightforward:

• Install the Kimi Client extension in VS Code (most popular option)
• Or run directly from terminal using their provided code snippets
• Enable the extension, and free-tier models auto-select without configuration

For my automation workflows, this eliminates the manual model-selection overhead I used to spend significant time on.

Current Limitations I Need to Flag

I’m not going to oversell this. There are genuine constraints:

• Weights unavailable for download—API-only currently. Kyutai says local weights are coming; I’ll test when they arrive.
• Quality ceiling: In my testing, it doesn’t consistently beat Claude 3.5 Opus (Anthropic’s absolute strongest model). It’s competitive with Sonnet-level performance—excellent for daily work, but not universally superior.
• Language quirks: The voice and mobile interfaces I tested defaulted to Chinese. English text interfaces work fine, but don’t expect seamless multilingual voice interaction yet.
• Documentation is Chinese-first—browser translation handles this, but it’s friction.

For the price, these are manageable trade-offs. But manage your expectations: this is a Claude Sonnet competitor at Claude Haiku pricing, not a free lunch.

The Bigger Picture for Builders

What Meituan/Kyutai achieved here signals something I predicted in my community discussions: AI capability is decentralizing faster than consensus expects. A food delivery company trained a frontier-class model. They did it without the hardware everyone assumed was mandatory. They released it under MIT license, letting anyone build commercial products on top.

For my own projects—automating e-commerce operations, building AI-assisted content workflows, training specialized agents—this expands the viable toolset dramatically. When I mentor developers in our live sessions, I emphasize cost sustainability: your AI infrastructure needs to survive your revenue ramp-up period. Models like this make that math work.

The companies actually building with AI right now—not just consuming chat interfaces—are going to benefit most from this wave. The moat isn’t access to expensive models anymore. It’s knowing how to compose, route, and deploy the right models for specific outcomes.

FAQ

Is Kyutai On Alpha really free to use commercially?

Yes. It’s released under an MIT license, which permits commercial use, modification, and distribution without restriction. When weights become available for download, you’ll be able to self-host for internal products. Currently, API usage has standard metering but no licensing fees.

How does the quality compare to Claude 3.5 Sonnet?

In my testing, it’s comparable to Sonnet-level performance for coding and analysis tasks, but doesn’t consistently exceed Claude 3.5 Opus (Anthropic’s top tier). The 1 million token context window matches or exceeds most Claude tiers. For daily development work, document analysis, and automation—it’s genuinely competitive. For frontier research or the most demanding reasoning tasks, Claude Opus still holds an edge.

Can I use this if I only speak English?

Text interfaces and API calls work fully in English—that’s how I’ve been using it. The web dashboard and documentation are Chinese-first, but browser translation handles this adequately. Voice features and some mobile app functions currently default to Chinese. If you’re comfortable with API integration or using OpenRouter as an intermediary, language isn’t a blocker.

What’s the cheapest way to get started?

OpenRouter with existing credits is fastest—no new account needed. For dedicated usage, Kyutai’s token packages (prepaid, ~$60 promotional tier) beat pay-as-you-go API pricing for consistent workloads. Their free context caching means repeated work on the same project costs progressively less. If you’re experimenting, start with OpenRouter; if you’re building a production workflow, the direct API with token packages optimizes costs.

Conclusion

I tested this model because the numbers didn’t make sense—a ghost topping leaderboards at impossibly low prices. Two months of quiet usage by developers like me validated the quality before the corporate reveal.

What Meituan’s Kyutai built isn’t just a cheaper Claude alternative. It’s proof that AI model training is escaping its hardware cage, that open-source licensing is becoming a competitive weapon, and that the companies willing to operate in secrecy for months can reshape market dynamics overnight.

For my daily work, this joins my toolkit alongside Claude, GPT-4, and specialized open models. The routing logic matters now more than model loyalty. I use what delivers the right quality at sustainable cost for each specific task.

The weights aren’t downloadable yet. When they are, I’ll run local benchmarks and share results. Until then, the API is production-ready, the pricing is genuinely disruptive, and the context window handles projects that would chunk and degrade on smaller models.

If you’re building AI-powered systems and haven’t pressure-tested Chinese models recently, you’re working with an incomplete picture of what’s possible. The food delivery company just schooled the pure-play AI labs on cost-engineering at scale. That’s worth paying attention to.

Watch the full video (in Turkish — English subtitles available):

Tools & Community

• TurkoLister — the AI listing tool I use to turn Amazon products into optimized eBay UK listings in about 60 seconds (from £4.99/month, £1 one-week trial).
• AI & E-commerce Community — my Turkish-speaking community ($19/month) with weekly live sessions.
• Subscribe on YouTube — new experiments every week.

The post How a Food Delivery Giant Built a $0.30 AI Model to Rival Claude appeared first on Digital Market Mentoring.