![Thumbnail (1920x1080)](https://i.ytimg.com/vi/SfP1YBO2tNo/maxresdefault.jpg)
# [Ornith 1.0 + DSpark is INSANE : Self-Scaffolding Local AI That Runs 85% Faster](https://www.youtube.com/watch?v=SfP1YBO2tNo)

**Visibility**: Public
**Uploaded by**: [Cloud Codes](https://www.youtube.com/@Cloud-Codes)
**Uploaded at**: 2026-07-02
**Published at**: 
**Length**: 14:22
**Views**: 13993
**Likes**: 568
**Category**: Science & Technology

## Description

```
How do you build a frontier-grade AI coding agent that runs 85% faster, entirely on your own local hardware, for zero API cost? It requires stacking two massive breakthroughs: DeepReinforce's new "Ornith 1.0" model, and DeepSeek's "DSpark" speculative decoding framework.

In this video, Cloud Codes breaks down the ultimate open-source AI architecture. First, we explore Ornith 1.0—a self-scaffolding AI brain built on Qwen and Gemma that actually taught itself how to plan, use tools, and verify code during reinforcement learning. 

Next, we dive into DeepSeek DSpark, the MIT-licensed speed layer that uses Speculative Decoding to make local inference up to 85% faster without losing a single drop of intelligence. Finally, we provide a step-by-step tutorial on how to wire Ornith and DSpark into the Claude Code terminal harness using vLLM—giving you a completely private, blazingly fast local coding agent that rivals Claude Opus.

⏱️ TIMESTAMPS:
0:00 - The Problem with Modern AI Agents
0:28 - Enter Ornith 1.0: The Self-Scaffolding Model
1:26 - DeepSeek DSpark: The 85% Speed Upgrade
2:14 - Deep Dive: How Ornith Actually Works (Qwen/Gemma)
3:44 - What is "Self-Scaffolding" AI?
6:08 - Deep Dive: How DSpark Speeds Up Inference
6:41 - Speculative Decoding Explained
8:57 - DeepSpec: The Open Source Training Toolkit
10:02 - Tutorial: Wiring Ornith + DSpark into Claude Code
11:35 - SWE-Bench Scores & The Honest Verdict
12:38 - Local vs Frontier: The Hybrid Strategy
14:08 - Summary: The Ultimate Local AI Stack

#localai #deepseek #ornith #systemdesign #softwareengineering #claude #artificialintelligence #cloudcodes #machinelearning

👇 SUBSCRIBE & WATCH NEXT
Subscribe for a new systems deep-dive every week: https://www.youtube.com/channel/UC0DZj1PNa_Fp0MU6uPSKv5w?sub_confirmation=1

📱 CONNECT WITH US
Twitter/X:  x.com/cloud_codes
Join our developer community: discord.gg/HVnH9SY48 

User Queries : 
how to run ornith 1.0 locally
deepseek dspark speculative decoding
claude code local model proxy vllm
ornith vs deepseek v4 swe bench
self scaffolding ai agents explained
how to run local ai coding agents
deepreinforce ornith qwen gemma
system design ai inference speed
open source alternative to claude code
deepspec speculative decoding tutorial
```

## Transcript

Watch a coding agent try to work. The
model is brilliant, but it just sits
there waiting for a human to tell it
exactly how. Almost every coding AI on
Earth is a smart brain wrapped in a
harness that a person hand-built for it
by hand in advance. Now, watch this one.
It writes its own plan, picks its own
tools, checks its own work, and repairs
its own mistakes, and no human wrote
that scaffold. The model authored it
itself. That is the exact part that
short-circuited people this week. This
is Ornith 1.0.
It dropped on June 25th from a research
lab called Deep Reinforce. Open weights,
MIT license, no regional locks. You can
download it tonight and run the whole
thing on your own hardware. And here is
the genuinely insane part. Ornith did
not get that scaffold from a clever
prompt. It learned to build it during
training, teaching itself how to behave
like an agent one reward at a time. Most
models never touch their own harness.
This one rewrote it from scratch. Want
proof it matters? The plain Qwen 9
billion that Ornith is built on scores
53 on SWE-bench.
Ornith takes that exact same size and
scores 69. Same parameters, same weights
underneath. 16 points purely from
learning a better process, and the
flagship is no toy, either. 397 billion
parameters scoring 82.4 on SWE-bench
verified, beating Claude Opus 4.7
outright. An open model you can download
right there in the frontier
conversation. Then, just 2 days later, a
second bomb drops. DeepSeek ships
DeepSpark. Same model, same weights,
nothing retrained at all, and suddenly
it is streaming up to 85% faster, and it
is completely lossless. Token for token,
the exact same answer, just delivered in
half the time. Not a smaller, dumber
model, a faster way to run the one you
already have. Here is why these two
belong in one single video. DeepSpark
speeds up Qwen and Gemma right out of
the box, and Qwen and Gemma are exactly
what Ornith is built on top of. The
self-scaffolding brain and the speed
layer fit together like a key in a lock.
So, put it all together. An open model
that scaffolds itself, running 85%
faster on your own machine for $0 a
token. Nobody had that a year ago. Let
us take the whole thing apart piece by
piece. Start with the brain. Ornith is a
family of open coding models from Deep
Reinforce, built on top of Gemma 4 and
Quinn 3.5, two already strong open
bases, then pushed much, much with
reinforcement learning. They did not
invent a new brain from nothing.
They took two good ones and taught them
how to be agents. It ships in four sizes
from one shared recipe. A 9-billion that
runs on a single card, a 31-billion
dense workhorse, a 35-billion mixture of
experts that holds the capacity, but
fires only a slim slice of experts per
token, and a flagship at 397-billion.
Laptop to data center, one family, one
training idea, wildly different price
tags, and these are not short context
toys.
Every size reads a quarter of a million
tokens at once, up to 400,000 for whole
repository work. The 9-billion fits on a
single 80-gigabyte card at around 19
gigs in half precision, small enough to
live on your desk, and the license is
the quiet headline.
Ornith is MIT, weights on hugging face,
no regional lock, no usage cap, no phone
home. You clone it, you own it, you run
it offline forever. That is a very
different promise from an API key that
can be revoked or repriced tomorrow
morning. They are agentic straight out
of the box, too. Every response opens
with a visible thinking block, then
emits clean, well-formed tool calls, all
in the same OpenAI style format every
harness already speaks. No exotic glue
required. That one detail is the whole
reason it slots into a tool like Claude
code with almost no effort. Now, what
actually is a scaffold? It is the
wrapper around the raw model, the plan,
the tool list, the working memory, the
checks and the retries, the
orchestration that turns a plain text
generator into an agent.
Normally, a human engineer writes it by
hand once, tunes it for a while, and
then freezes it, and reuses that one
harness for every task that follows.
Ornith flatly refuses to freeze it. It
treats the scaffold as a learnable
object that evolves right alongside the
model itself. Instead of one fixed
harness bolted onto every problem, each
kind of task grows its own tailored
strategy discovered by the model, not
handed down to it by an engineer. The
training loop runs in two stages. First,
given the task, the model proposes a
refined scaffold. Then, conditioned on
that scaffold, it actually attempts to
solve the task. The reward from how well
it solved flows back into both stages at
once, so the planning and the answering
are forced to improve together. Repeat
that over thousands of rounds, and
something quietly profound happens. Good
scaffolds get selected, weak ones get
mutated away, and per-task strategies
simply emerge on their own. The model is
not only learning answers anymore, it is
learning how to work, how to orchestrate
itself toward an answer. And think about
what that actually buys you at the end.
A model that plans before it acts, that
reaches for a real tool instead of
hallucinating, that reads its own
output, notices the failure, and
recovers instead of charging ahead.
Those are the exact habits you normally
have to bolt on from the outside. Of
course, a model that designs its own
process could learn to cheat it, reading
the hidden test, hardcoding the expected
file, faking a green check mark. So,
Deep Reinforce built three walls, a
fixed outer trust boundary it cannot
touch, a deterministic monitor that
zeros out any forbidden move, and a
frozen judge model that can veto an
entire run on sight. The payoff is
efficiency you can actually feel. That
little 9 billion lands at 69 on SWE
bench verified, beating Gemma 4 at 31
billion, and matching QN all the way up
at 35. Learning a better process, it
turns out, is worth a genuinely
startling amount of raw parameters. The
mixture of experts version pushes the
idea even harder. At just 35 billion, it
beats every similar size model. And on
Terminal Bench, it actually edges out a
QN model more than 10 times its size.
Smaller weights, smarter orchestration,
higher score. The scaffold is doing real
work. Now, the second half of the title.
The very same week Ornith landed,
DeepSeek and Peking University dropped
DeepSpark. And exactly like Ornith, the
headline is not a shiny new model. It is
a way to run the models we already have
far faster, given away completely free
under MIT. Start with why big models are
slow. To write a single token, the model
fires a full pass through every
parameter it has. At this scale, the GPU
spends more time hauling weights through
memory than actually computing anything.
So, the chip sits half idle, just
waiting on itself, one token at a time.
Speculative decoding breaks that pattern
completely. A small, fast draft model
guesses a whole block of tokens ahead.
The big model then verifies the entire
block in one single pass, checking five
guesses for almost the price of one.
Every guess it accepts is a token you
got very nearly for free. Because the
big model was going to sit idle during
that pass anyway. And crucially, it
cannot quietly lower your quality. The
verifier uses rejection sampling, which
keeps the final output mathematically
identical to normal decoding.
Wrong guesses are simply thrown away.
You only ever keep the tokens the real
model would have written anyway. You
just get them sooner. But older drafters
forced a painful trade-off. Sequential
ones, like Eagle, guess accurately, but
they slow right down as the block grows.
Parallel ones, like DeepFlash, are
cheap, yet they guess each token blind
to its neighbors, so the tail of the
block rots and gets rejected. They call
it suffix decay. It all reduces to one
clean equation. Latency equals draft
time plus verify time divided by how
many tokens you actually accept per
cycle. So, there are exactly three ways
to win. Draft faster, draft better, or
verify smarter. DSpark unusually reaches
out and pulls all three levers at the
same time.
Its first move is to stop choosing. A
fast parallel backbone proposes the
whole block at once, then a tiny
sequential head, low rank Markov, adds
one quick correction nudging each token
based on the one right before it. Cheap
like parallel, accurate like sequential,
with almost none of the cost of either.
Two more tricks seal it shut. A
confidence head scores each guess, and a
hardware-aware scheduler verifies more
tokens when the GPU is idle, and fewer
when it is slammed, and it runs a full
step ahead, so that whole cleverness
costs no clock time of its own. Offline,
the numbers are already convincing.
DSpark accepts 26 to 31% more tokens per
cycle than Eagle, and 16 to 18% more
than Flash. A two-layer DSpark even
beats a five-layer Death Flash. Better
guessing from a smaller and cheaper
drafter. And in live production, the
payoff is the headline. Per user
generation runs up to 85% faster on the
Flash model, and 78% faster on Pro, at
the same total throughput, same servers,
same weights, very nearly double the
speed for nothing. And they open source
the entire factory, too, called Deep
Spec. The full MIT pipeline to train
your own drafter, not just a canned
demo. It ships three drafting
algorithms, and it targets Qwen and
Gemma right out of the box on day one.
Now, read that last part again, slowly.
Deep Spec was built to speed up Qwen and
Gemma, and Ornith is built on Qwen and
Gemma. The exact bases the
self-scaffolding brain stands on are the
exact bases the speed layer was designed
to accelerate. These two releases were
almost literally made for each other.
And this is precisely why coding agents
care so much. An 85% speed up is not a
chat window party trick. It is your
agent grinding through a long 20-step
task in half the wall clock time for the
exact same bill. At the agent layer,
speed is not a nicety. It is the whole
game. So, here is a stack the title is
really pointing at. At the bottom, a
brain that already knows how to be an
agent, Ornith. Wrapped around it, a
serving layer that makes it fly, Dspark.
And on top, a harness holding the real
keys to your machine. Three layers, and
every single one of them is open. Step
one, serve the brain. A single VLLM
command brings Ornith up as an open AI
compatible endpoint, listening on a port
on your own box. No cloud account, no
waiting list, no rate limit, no token
meter ticking in the background. Step
two, bolt on the speed. Attach the
Dspark drafter to those very same
weights, and the endpoint keeps
answering with the exact same output,
just up to 85% faster. Nothing
retrained, nothing swapped out. Same
brain, much quicker hands. Step three,
point your harness at it. Set one base
URL name Ornith as the model, and Claude
code will happily drive your local
accelerated open brain using the exact
same command line you already know by
heart. One honest note before you get
carried away.
Running the pre-pennant checkpoints in
VLLM or SG Lang is genuinely easy. That
part is a weekend. But training your own
custom drafter from scratch is a data
center job, wanting an 8 GPU node and
terabytes of cash. Use the checkpoints
they shipped and you skip all of that.
And now just sit back and watch the loop
run. The harness hands Ornith the goal.
Ornith thinks, then plans out its own
approach. It opens the file, runs the
test, reads the error,
>> [music]
>> and because Dspark is underneath, the
tokens come back fast enough that the
whole thing feels genuinely live. Give
it something real, fix this failing
test. Ornith reads the stack trace,
writes its own repair plan, edits the
broken function, reruns the whole suite,
and the red bar flips clean to green. A
local model, a self-written scaffold,
real tools on your disk, and half the
usual weight. Now, let us stay honest
about exactly where this lands. On SWE
bench verified, the flagship 82 beats
DeepSeek and MiniMax and cleanly ties
Opus 4.7, but it still trails Opus 4.8
at 87. Close, genuinely close. Just to
be clear, not out in front. And keep
DeepSpark honest, too. Lossless means
faster, not smarter. It does not add a
single point of raw intelligence. And
every speed number here is DeepSeek
measuring DeepSeek on DeepSeek servers
against a DeepSeek baseline. No outside
lab has independently verified the peak
figures just yet. So, when does this
OpenStack win outright? When the code
simply must stay on your own hardware.
When it has to run with no internet at
all. When the license has to be
permissive enough to ship. And when you
flatly, permanently refuse to pay by the
token. And when does the close frontier
still win? On the hardest, longest
horizon jobs, the sprawling many-step
tasks, where the very top of the
benchmark is exactly the handful of
points that decide whether the run
finishes cleanly or quietly stalls
halfway and burns your afternoon. Which
is why the real answer was never one or
the other. Keep the harness as your
constant, it never has to change, and
just swap or accelerate the brain to fit
the job. Open and local and fast by
default. Frontier on the rare days it
genuinely counts. Same hands, different
brain. Step back and notice what
actually changed here. For two solid
years, the race was simply who has the
smartest model. Those top scores have
now bunched together within a few points
of each other.
So, the fight quietly moved to the
serving layer that decides how fast a
model runs, and the agent layer that
decides how well it actually works on a
real task. And that is the real headline
hiding underneath both of these
releases.
An open brain that scaffolds itself,
running 85% faster on hardware you
actually own. The line between open and
frontier has never ever been this thin.
A year ago, this whole setup was a
research demo. Today, it is a Tuesday
afternoon. So, let us kill the myth on
the way out. A model that learned its
own scaffold does not delete the
harness, and a faster decoder does not
delete the model. These are different
layers of one single stack, no more
rivals than an engine and the car around
it. The best setup runs a great one of
each. That is the whole story, start to
finish. Ornith is an open brain that
taught itself how to work, its own plan,
its own tools, its own checks. D-Spark
is the free speed layer that makes it
fly, built for the very bases Ornith
stands on. Stack them together, and you
get local, private, frontier-class
agentic coding, running fast on your own
machine for $0 a token. If that finally
made all the pieces click into place,
this channel is completely full of
breakdowns built exactly like this one.
So, subscribe to Cloud Codes, stick
around for the next drop, and I will see
you in the next one.