mechinterp, reasoning, autoresearch // founder @lightfastai https://xitter.cf/t.co/ljihJtt7Si
Australia
Joined January 2013
- Tweets14.1K
- Following2.2K
- Followers2.8K
- Likes25.3K
working through mutli-agent swarms and associated rsi optimizations
some findings are that frontier on swarms lead with acyclic graphs — where I see value in researching into more non-common approaches such as cyclic graphs
a inside look into human society, we somehow naturally models our civilization through many levels of cyclic and acyclic in the mix
combined approaches are yet to be studied either
an interesting paper is gptswarm with it's associated rsi optimization below
arxiv.org/html/2402.16823v3
rsi-benchmark.com/tasks/agen…
question, how many of you have used/are using claude workflows and ultracode?
0%yes
0%no
0 votes • 20 hours
a question i keep asking myself is given we are moving into scaling up autoresearch to 10000 agents, what do mechinterp methods need to evolve to study at scale. my intuition tells me the future mechinterp tools will be studying joint activations across 100s of instances at once.
jp retweeted
It is becoming f*cking dangerous
A 23-year-old dev from China just ran 300 Claude Code agents in parallel and hooked them to a verification layer so none of them could bullshit him
He opens the live dashboard:
- 300 agents writing and checking at the same time
- Every output verified against the source in ~100 ms
- Three passes over 100 company profiles → zero errors left
- Everything dumped straight into an Obsidian vault
The trick is the split: one model does the work, a cheaper one decides if the claim is actually true. The loop doesn’t stop until everything checks out
An analyst team would bill weeks for this. He got it in one run
Same kind of Second Brain + swarm setup that keeps circulating. Bookmark the full breakdown
in a world attention is scarce, this is one you should pay attention to
Replacing backprop with zeroth-order optimization is inevitable.
Introducing Noise: a speedrun for pretraining without backprop.
Last week we presented Dust, the first method to approach backprop with SGD for pretraining transformers. We think another 1,000x improvement on top of it is possible, and it will require *co-designing* credit assignment, optimizers, architectures, and eventually, hardware.
We built Noise to iterate on this faster.
jp retweeted
Yep. People outside the data field (and those new to it) are generally overestimating how much you can teach a model just by pumping raw data from a particular domain through it. Similar to the relationship between unsupervised and supervised learning -- the former is cheap, high volume, and can get you a lot of low-hanging fruit, but a model is never production-ready until you've tackled a significant portion of the long tail, and that always requires more targeted curation: up- and down-sampling different sub-populations, targeted examples to address targeted failure modes, high precision and high taste solutions that convert raw knowledge into positive user experience, etc.
As the online hype around AI data brokering hits a fever pitch, a lot are missing the basic distinction between
- (A) Unrefined data for pre-training: I.e. raw company records (potentially de-identified)
- (B) Refined data for post-training/eval: I.e. well-formed, high-quality tasks, envs, rubrics based on private data or human traces
(A) is low margin brokerage - and will commoditize rapidly, esp as pre-training data curation techniques mature and increase discriminative capabilities for buyers.
(B) is an incremental (but exciting) evolution of the sophisticated frontier data/envs that AI data labs/vendors already build. Margin/differentiation here will only increase as the frontier continues to advance, raising the quality and complexity bar.
rsi is design principle. it is one where the system improves itself overtime. rsi is applicable to a broad range of systems, even ourselves. we humans are learning and continually updating our understanding and knowledge modulated by our perception of the world. even our perceptive is a form of rsi. there is no single use-cases, its general.
when ppl say “recursive self-improvement” (RSI), what exactly do they mean?
i asked 3 AI friends, everyone gave a different answer...
a) rejection sampling/re-weighting samples: sample M solutions for a target task from θ_t, score with some verifier V, keep the n_elites or reweight samples somehow, fine-tune θ_{t+1}. repeat. (e.g. STaR, RLVR, DeepseekR1, , DAgger, Cross Entropy Method)
b) self-play: learn by playing against yourself (θ_t) vs previous checkpoints (θ_{t-1}), optionally with search like MCTS. Mine traces somehow. RL train +1 for winning traces/-1 losing traces. repeat. (e.g. AlphaZero on some verifiable task)
c) harness self improvement/metalearning: the agent rewrites its own code, tools, or training algorithm to improve next time on some target task, evaluates the changes to the "harness" on goal task, keep diffs to harness that improve on goal task. repeat. (e.g. metaharness, DGM, Prime Agent, and more classically MAML, RL^2, L2LBGDGD, DiscoRL, etc)
which do they mean? and which is the right RSI approach for verifiable tasks?
the true rsi loop is chip design x model architecture x inference eng x gpu utilization
did i miss something?
arc-agi and adjacent benchmarks are the only ones that really matter — others are slop esp the coding ones
a simple check is to apply binding rules to destructive actions — there are many ways but if your agent is the one that decides for you the way probs ngmi
opus 5.5 just deleted my database
always thought something like this would never happen to me
luckily it was only my dev database, but it also had access to production
just a reminder how important database backups are, especially now that we're letting ai agents do more and more things on their own
i can totally see this happening to a lot of people
be careful out there guys
one thing i've done this week is gone through a bunch of projects i've started across the past 3-5 years and rewrote all of it. it's that time where we can single prompt fix whole repo's. quite a sight.
protip
your only dev/workflow goal in this next few months should be to get 100-500 agents running 24/7 with ultracode — apply the 80/20 rule as much as you can while doing so
spend extra hours obsessed on removing every restriction that causes your agent to stop or optimize token usage and save focus on 40-70% token usage
once u are hyper obsessed on these optimizations and workflow goals and have ~100 agents running at least 4-8 hours a day every day, you'll start feeling the exponential
ps running ~100-200 agents and depleting all usage in < 2 hours is an expensive learning opportunity but one you should make time and time again
