LumaByte (@LumaByteCo) header
LumaByte (@LumaByteCo) profile picture

AI-native studio. We ship production AI tools & open-source software — Production AI, and keep it running.

online
Joined October 2016
Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)Photo by LumaByte (@LumaByteCo)
LumaByte retweeted
Kimi K3.1 Pro scores 65.7 on Terminal-Bench 4.0 in its own lab's table: ahead of GPT-6 Astra (58.2) and Claude Fable 5.1 (57.9), 0.7 behind Opus 5.5 (66.4). Open weights, 2.8T MoE, 104B active. Moonshot's table, where it leads: - Terminal-Bench 4.0: 65.7 vs 58.2 GPT-6 Astra, 57.9 Fable 5.1 - SWE Marathon v1.1: 51.7 vs 46.3 Opus 5.5 - BrowseComp: 92.1 vs 91.5 GPT-6 Astra - HLE-Full with tools: 70.0 vs 67.7 Opus 5.5 Where it trails: - Program Bench: 31.5 vs 65.0 Opus 5.5 - Terminal-Bench-Science 0.1: 38.1 vs 68.1 GPT-6 Astra - HLE-Diamond: 39.4 vs 65.8 GPT-6 Astra - ExploitBench: 74.7 vs 100 GPT-6 Astra Fine print: Moonshot ran its own model with the Claude Code harness; the rival scores are the highest from those labs' blogs or public leaderboards. Not an outside test. Licence: free to use and fine-tune, but a company selling model-as-a-service with over $20M in 12 months needs a separate deal (section 2). Not OSI. No Ollama page for K3.1 (checked today), and at 2.8T it is rented, not run at home. For agent work: the open model with the published table, or the closed one that wins on Program Bench and the science test? huggingface.co/moonshotai/Ki…
8
2
8
234
LumaByte retweeted
Baidu released the base weights of ERNIE 5.5 Flash on 5 November: 280B parameters in total, 14B active per token, and the checkpoint straight out of pre-training, before any instruction tuning. So it is a starting point to fine-tune, not a chat model. In Baidu's own table, against three base models of similar size (DeepSeek V4 Flash Base, Hy3 preview Base, MiMo V2.5 Base), it beats the best of the three on MMLU-Pro (78.4 vs 69.2), HumanEval+ (82.3 vs 78.0) and LiveCodeBench (40.1 vs 33.5). It falls behind on ChineseSimpleQA (73.0 vs 75.3), FullStackBench (54.6 vs 56.7) and HELMET-Rerank (56.2 vs 60.0). Weights are on Hugging Face in FP8 and BF16. There is no Ollama page for it (checked today), and at 280B it is not a laptop model anyway. The licence is Baidu's own (ERNIE 5.5 Flash Base Model License v1.0), not an OSI licence. Non-commercial use is free. Commercial use is free up to US$50 million a year in related revenue after a one-time notice to Baidu; above that you need written authorisation. And the grant only covers its "Territory": everywhere except the European Union, the United Kingdom and South Korea. ernie.baidu.com/release/erni…
1
1
2
107
LumaByte retweeted
Ripple-65B Preview scores 80.5 on Terminal-Bench 2.1 in its own lab's table, level with or ahead of open models 8 to 15 times its size. 65B dense, Apache 2.0, out 4 Nov. Ricursive's table, where it leads: - Terminal-Bench 2.1: 80.5 vs 80.1 Reflection Beam 501B, 76.4 Muse Spark Open 816B, 63.8 Inkling 975B, 56.4 Nemotron 3 Ultra 550B - SWE-bench Pro v2.0 Hard: 79.1 vs 76.5 Reflection Where it trails: - SWE-bench Verified: 76.5 vs 81.6 Reflection - MCP Atlas: 71.7 vs 89.2 Muse Spark Open - DeepSWE 1.1: 44.3 vs 60.0 Muse Spark Open - GPQA Diamond: 85.2 vs 90.6 Reflection Dense means all 65B parameters run on every token; those rivals are MoE. The lab says most models scored lower on Terminal-Bench under the official harness, some rival numbers are its own re-runs, and the release is a Preview with light post-training. 1M context, 12T training tokens, an NVFP4 build it says fits a DGX Spark. No Ollama page (checked today). For a coding agent, which one do you run: the 65B model that fits on one box, or a 500B+ MoE that wins on SWE-bench Verified and tool use? huggingface.co/ricursiveAI/R…
4
1
7
236
LumaByte retweeted
DiffuSpace released Clover-35B-A3B-Preview (28 Oct), an open-weights 35B model (about 3B active) that writes blocks of text in parallel, a diffusion model, instead of one token at a time. In the lab's own table, against Qwen3.6 35B-A3B: - SWE-bench Verified 73.6 vs 65.8 - Terminal-Bench 2.1 51.7 vs 43.1 - SWE-Pro 46.5 vs 42.7 - ZebraLogic 95.8 vs 89.2 It trails on HLE text-only (12.8 vs 21.2) and AIME 2026 (83.3 vs 90.4). The baselines are the lab's pick, and the 680 tokens/s speed claim is its own test on a GB300. Apache 2.0 weights, marked Preview, custom code required, about 69 GB in BF16, no Ollama page (checked today). SGLang and llama.cpp backends are in the repo. Coding agent or hard maths: which one do you pick, the faster diffusion model that wins on SWE-bench, or the standard one that wins on AIME? huggingface.co/Diffuspace/Cl…
2
4
104
LumaByte retweeted
SenseNova released SenseNova-Loop-9B-Preview (30 Oct), an open-weights 9B model that runs the same block of layers twice: 32 layers stored, 56 layer-steps per answer. In the lab's own chart: - BIRD-Dev 71.38, next model listed 69.84 - WorkBuddy 66.89 vs 61.98 - TeamBench 48.89 vs 44.44 - AutomationBench 13.72 vs 10.17 It trails on Terminal Bench 2.1 (40.45 vs 49.44 for Nanbeige 4.2-3B and 47.19 for Qwen3.5 27B) and tau3-Banking (18.56 vs 19.59). The comparison set is the lab's pick. Apache 2.0 weights, marked Preview, tech report TBD, no Ollama page (checked today). Runs through Transformers with custom code. Which is better depends on the job: the looped small model looks stronger on SQL, spreadsheet and team-task benchmarks, the bigger models on terminal work. huggingface.co/sensenova/Sen…
4
2
5
122
LumaByte retweeted
Baidu released Unlimited-OCR 2, an open-weights model that reads a 100-page document in one pass. By the paper's own tables: - MarathonDocBench (100+ pages): 77.06, next model listed (Kimi-K3) 33.74 - MPDocBench (tens of pages): 84.59 vs 78.30 for Qwen3.8-Max - Peak KV cache while reading: 1.77 GB vs 47.00 GB with standard decoding It trails page by page: on OmniDocBench v1.6 it scores 94.02, behind TeleOCR (96.91, 1.2B) and OvisOCR2 (96.47, 0.8B). MarathonDocBench is also Baidu's own new benchmark. 3B parameters, 0.5B active, MIT licence. No Ollama page yet (checked today); the repo targets SGLang on an 80 GB A800. For parsing long documents locally, would you pick the one built for 100+ pages, or a small specialist that scores higher page by page? huggingface.co/baidu/Unlimit…
6
2
8
269
LumaByte retweeted
Microsoft's 41K-star BitNet project is now doing something particularly interesting for RAG and local AI. It has brought 1.58-bit weights to text embedding models. And in Microsoft's CPU benchmarks, its 600M-parameter embedding model achieves up to 2.28× the throughput of its FP16 baseline. This builds on the same BitNet research that produced the 2B-scale language model trained on 4 trillion tokens. The original idea was to train neural networks whose linear-layer weights take only three values: -1, 0, and +1. With specialized inference kernels, this can substantially reduce weight storage and memory traffic. Microsoft has now released two BitNet embedding models: → BitNet-embedding-270M, with 640-dimensional embeddings → BitNet-embedding-0.6B, with 1,024-dimensional embeddings Both support sequences up to 32,768 tokens and use ternary weights with 8-bit activations in their quantized linear layers. The 600M model is especially interesting. In Microsoft's reported English multilingual embedding benchmark comparison, it achieved an average score of 67.60, compared with 67.95 for its FP16 teacher. Meanwhile, with 8 CPU threads, the optimized 1.58-bit implementation delivered between 1.42× and 2.28× the FP16 prefill throughput, depending on sequence length. That performance difference matters for applications that repeatedly encode documents, queries, and other text. The implementation also reveals an important engineering detail. Its advantage becomes smaller as sequences grow longer, because attention computation starts accounting for more of the workload. And the project goes beyond embedding models. Microsoft has also released CPU optimization work, custom GPU inference kernels, and related low-bit speech-recognition infrastructure. The GitHub repository includes the inference engine, optimized kernels, supported models, and conversion tools. For engineers working on RAG, local inference, or resource-constrained AI systems, BitNet is a very interesting project to study. Fully open source under MIT. GitHub: github.com/microsoft/BitNet
16
2
4
28
2,343
5 Tips to Master Backend Engineering in the AI Era 1. Master Backend Fundamentals Build a strong foundation in HTTP, REST APIs, authentication, authorization, databases, caching, message queues, and server-side programming. Understand how modern backend systems communicate and operate. 2. Learn AI Integration & LLM Engineering Understand how to integrate OpenAI APIs, LLMs, embeddings, RAG pipelines, AI agents, function calling, and Model Context Protocol (MCP) into backend applications. 3. Master Databases & Distributed Systems Learn PostgreSQL, MongoDB, Redis, Kafka, database indexing, replication, sharding, event-driven architecture, and distributed transactions. Modern AI applications still depend on reliable data infrastructure. 4. Become an Expert in Cloud & Infrastructure Master Docker, Kubernetes, CI/CD, AWS, serverless computing, Terraform, observability, and microservices. Learn how to deploy, scale, monitor, and secure production-grade backend systems. 5. Build AI-Powered Backend Projects Move beyond tutorials. Build AI-powered SaaS platforms, RAG applications, AI agents, intelligent search engines, recommendation systems, document-processing APIs, and automated workflows. Focus on scalability, security, reliability, and real-world performance. Grab Backend Engineering ebook: codewithdhanian.gumroad.com/…
9
27
1
157
4,570
LumaByte retweeted
why Ollama Cloud has grown 200x since the start of the year 👇 @togethercompute @vipulved @jmorgan
32
17
3
134
14,499
Recursive released Flint: an open-weights coding model with 39.8B total parameters and about 2.5B active per token, built to run on a laptop. By Recursive's own chart, it beats Qwen 3.6 (a similar-size MoE, 3B active) on: - Terminal-Bench 2.1: 54.9 vs 44.9 - SWE-bench Pro v2: 89.7 vs 73.8 - IFBench: 89.2 vs 67.9 It trails the dense Qwen 3.8 (27-31B) on: - Terminal-Bench 2.1: 54.9 vs 73.0 - SWE-bench Pro v2: 89.7 vs 94.9 - LiveCodeBench v6: 80.3 vs 90.3 Recursive claims more than 5x the speed of dense models with similar coding scores. On Ollama: ollama run flint (23 GB download, 256K context). Licence: Apache 2.0. For a local coding agent, would you take the fast small-active model or the dense one that scores higher on the hard tests? recursive.com/updates/introd…
11
3
9
405
Nanbeige released Nanbeige4.3-33B: an open-weights 33B model for coding and office-style agents, with a 512K context window. By the lab's own table (each model at its highest thinking effort), it beats Qwen3.8-27B on: - Terminal-Bench 2.1: 80.9 vs 73.0 - DeepSWE: 65.5 vs 42.5 - Toolathlon-Verified: 70.4 vs 68.5 It trails on: - SWE-Bench Pro: 60.3 vs 61.7 (Qwen3.8-27B) - GDPval: 84.8 vs 86.4 (Qwen3.8-27B) - GPQA Diamond: 89.5 vs 91.3 (Gemma4-31B) 17 of the 20 rows go its way. The weights are 66 GB at BF16, so a quantized build is the realistic local route; there is no Ollama library page, only community GGUFs on Hugging Face. Licence: Apache 2.0. For a coding agent on your own hardware, would you take the 33B that wins most rows or the 27B that still wins on SWE-Bench Pro? huggingface.co/Nanbeige/Nanb…
6
1
6
257
LumaByte retweeted
Harness Engineering from Scratch 🚀 Found this excellent 21K+ star GitHub repo that teaches you how to build reliable AI coding agents, from the ground up. An entire open-source curriculum with 14 lectures, 8 hands-on projects, and 8 progressive learning phases. What makes it useful is the approach: instead of just learning concepts, you gradually build the engineering environment around an AI agent, using the same real application throughout the course. What's inside: → Agent instructions and repository structure → Context management and persistent memory → Multi-session continuity and task handoffs → Task planning, scope control, and progress tracking → Testing, verification, and observability → Automated coding loops and maker-checker workflows → Graph orchestration, parallel execution, and rollback Includes practical projects, reusable templates, a harness-creator skill, and technical breakdowns of how Claude Code, Codex, Pi, and DeepSeek build their harnesses. Available in 15 languages. Perfect for software engineers and AI developers who want to move beyond prompting and understand how reliable coding agents are actually built. Completely free and open source. Here's the GitHub Repo: github.com/walkinglabs/learn…
76
228
16
1,454
69,626
Thanks to @lightseekorg for Day-0 support with TokenSpeed!
Day-0 support for @MiniMax_AI M3.1 Flash is live in TokenSpeed. DSpark speculative decoding and MXFP8 + NVFP4 mixed precision on Blackwell. TokenSpeed is featured in the official deployment guide. 📖 huggingface.co/MiniMaxAI/Min… 👉 github.com/lightseekorg/toke…
11
3
1
177
21,552
Modern Computer Science Cheatsheet
5
31
2
260
6,563
Liquid AI released LFM3-1.7B: an open-weights text model for local agents that fits in about 1 GB at 4-bit. By Liquid's own table, it beats Qwen3.5 9B (a model about 5.7x larger) on: - tool use: BFCL V4 71.4 vs 62.8 - coding: LiveCodeBench v6 73.5 vs 69.9 - instruction following: IFEval 96.7 vs 92.1 It trails on knowledge and long context: - GPQA Diamond 63.4 vs 80.4 - RULER 128K 65.6 vs 87.1 256K context window. On Ollama: ollama run lfm3 (the default download there is 1.7 GB). Licence: LFM Open License v1.0, not an OSI open-source licence. Commercial use is covered only for organisations under $10M annual revenue. For a local agent, would you take the small model that is good with tools or the big one that knows more? liquid.ai/blog/lfm3
6
2
11
254
Moonshot's Kimi K3.1 Pro is live in its app and API: a 3T-class open-weight model with a 1M-token context window. The weights themselves are promised by Nov 4. What they report (their numbers, not independent ones): - Terminal-Bench 4.0: 65.7%, against 58.2% for GPT-6 Astra and 66.4% for Claude Opus 5.5 - Kimi Code Bench 3.0 Long-horizon, their internal benchmark: 61.2%, up from 55.95% for K3 - A factual-accuracy stress test: claim-level hallucination rate down from 23.4% to 8.3%. They say it does not represent everyday error rates The part worth reading: for the open-weight release they removed cyber-related data from both mid-training and the RL stage. On their in-house exploit benchmark, the checkpoint without that removal solves 90.5% of problems at pass@3, the final model 81.0%. Removal lowered it, and stronger general coding still raised it over K3. Can't run it locally yet: no weights, and the page names no licence, so no ollama line until they land. Would you run it yourself once they do? kimi.ai/blog/kimi-k3-1-pro
1
2
4
182
A container is a normal process that the kernel runs with a few restrictions added, and you can still find it on the host under /proc. What the restrictions are: 1. Namespaces limit what the process can see. Linux has eight kinds, each isolating one resource: mount points, process IDs, network devices and ports, the hostname, System V IPC and message queues, user and group IDs, the clocks, and the cgroup root directory. 2. Cgroups limit what it can use. They organise processes into groups whose CPU time, memory and other resources can be limited and monitored. 3. The root directory is swapped. An image is just a folder, and the runtime makes that folder the process's root with chroot or pivot_root. Someone writing their own container runtime for fun found a few oddities on the way. runc, Docker's runtime, is written in Go, which is multi-threaded, so it runs a C module before Go's runtime starts and re-executes /proc/self/exe to stand in for fork. And the Docker daemon has usually run as root, because many of these kernel APIs needed it, though that is improving. Sources: the namespaces(7), cgroups(7) and pivot_root(2) man pages, and "Docker is weird" on codeandcake.dev. codeandcake.dev/posts/2026-1…
1
2
106
A git hook that quizzes you on your AI-written code before it ships. Sphinx (MIT, created 14 Oct) pauses a push to a protected branch and asks what your change will do: what happens on a retry, what if a worker crashes mid-job. Miss it and it explains, then gives you a new scenario. Pass, and the push continues, whether you or your agent ran git push. The questions come from a separate reviewer model that reads the committed change and never saw the chat that produced it. The check is open-book. One thing to know before installing: sphinx install sets your global Git core.hooksPath, so pushes to main or master in every repo on the machine get checked. github.com/parthh01/sphinx
1
1
1
93
162,000 GitHub stars for a project that turns AI into an entire team of specialists •⁠ ⁠Clone msitarzewski/agency-agents from GitHub •⁠ ⁠Pick an agent persona for coding, marketing, design or QA •⁠ ⁠Add its instructions to Claude Code or Codex and assign a task Stop asking one AI to do everything when you can give every task to a specialist Repo: github.com/msitarzewski/agen…
11
12
1
143
40,035