Pinned Tweet
برای #زندگی_نرمال ی که از همه مون گرفته شد...
Für das normale Leben, das uns gestohlen wurde....
For the normal life that was stolen from us...
#MahsaAmini
#مهسا_امینی
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
REA is most dangerous thing on the internet right now...
It lets your AI agent reverse engineer any app, down to the binary
If you use it correctly, you can rebuild any feature you pay for, for FREE
In this article, I show you how:
Aligorithm 🇮🇷🇱🇺 retweeted
this is f*cking insane, Claude Code agents turned a reading list into a lab you can run in your browser
Boris Cherny (creator of Claude Code) gave 12 agents 64 research papers and one assignment: build a browser lab where readers can rerun the experiments
pick a fluid simulation, change the conditions and watch how the result changes
switch methods while keeping the same scene. inspect the equations, code and measurements beside the animation
give each group a specific job:
→ readers extract equations, assumptions and experimental settings
→ builders turn the methods into runnable code
→ reviewers compare outputs against the papers
→ interface agents build the controls for exploring each experiment
a simulation can look convincing while producing the wrong answer
reviewers check whether it preserves mass, stays stable and matches the paper's measurements before accepting the implementation
every experiment has to show:
> the claim being tested
> the conditions used
> the difference from the reference result
> the details still needed to verify it
the lab covered 11 methods across 28 reference scenes. seven matched the selected reference results within the stated tolerances; four stayed marked for further review
give Claude Code your paper collection, then ask:
"Turn these papers into an interactive browser lab
1. Extract implementable methods, equations and experimental settings. Attach page references and flag missing details
2. Assign independent methods to separate agents. Use shared inputs and measurement tools so the results can be compared
3. Have reviewers check each implementation against the paper. Record discrepancies and keep unverified results clearly marked
4. Build controls for changing parameters, comparing methods and opening the code behind each result"
start with one paper and reproduce one reference experiment before adding more agents
include the inputs, dependencies and checks so the next reader can rerun it from a clean checkout
watch the agents at work below
Aligorithm 🇮🇷🇱🇺 retweeted
راهنمای سفارش پیتزای ایرانی طور از اپ دومینوز:
اول میرین اون دیل choose any two for 6.99 رو انتخاب میکنید.
بعد build your pizza رو انتخاب میکنید.
بعد کراست رو handmade pan انتخاب کنید.
تاپینگ ایرانی طور میشه
Beef
Philly steak
Italian sausage
همراه با قارچ و فلفل سبز
گزینه پنیر اضافه و پخت well done فراموش نشود. با تشکر
AI agents are getting f...cking dangerous with real data
9 GitHub repos for building a GPT 6 Astra system that can explore databases, write SQL, run analysis, and turn raw numbers into decisions
01 Vanna
▸ github.com/vanna-ai/vanna
→ natural language questions into SQL queries
GIVE AI ACCESS TO DATA
02 DB-GPT
▸ github.com/eosphoros-ai/DB-G…
→ build AI applications around private databases
03 MindsDB
▸ github.com/mindsdb/mindsdb
→ connect AI workflows to enterprise data
MAKE THE DATA USABLE
04 DuckDB
▸ github.com/duckdb/duckdb
→ run analytical SQL directly on local files
05 Polars
▸ github.com/pola-rs/polars
→ process large datasets with fast DataFrame operations
06 DataFusion
▸ github.com/apache/datafusion
→ build custom SQL query engines
TURN ANALYSIS INTO ACTION
07 PandasAI
▸ github.com/sinaptik-ai/panda…
→ ask questions about datasets in natural language
08 Evidence
▸ github.com/evidence-dev/evid…
→ turn SQL queries into interactive reports
09 Metabase
▸ github.com/metabase/metabase
→ explore metrics and build dashboards
the architecture:
question → schema → SQL → query → validate → analyze → visualize → decision
3 builds worth stealing:
finance: Vanna → DuckDB → Evidence
business: MindsDB → Polars → Metabase
research: DB-GPT → DataFusion → PandasAI
here's what makes this interesting
most AI agents can explain your business
very few can actually inspect the numbers behind it
GPT 6 Astra + the right GitHub stack changes what you can build
the next useful AI assistant won't just answer questions
it'll know where to look for the answer ⭣
Aligorithm 🇮🇷🇱🇺 retweeted
Quasi-RH?!?!???! Are you kidding me? If a human did this, it would be an instant Fields Medal, no questions asked.
RH says zeta has no zeros in Re(s)>1/2. The best we had until a second ago was a region that got thinner and thinner the higher up the imaginary axis you go. I thought maybe they’d fatten that up a bit, that’d be a massive breakthrough. But no. They got a zero free strip!!!! Insane
We’re releasing a broad range of new mathematical results produced by an internal frontier model.
We’ve been consulting with the independent Advisory Group on Mathematics and Artificial Intelligence at the Institute for Advanced Study, and we have drawn on their advice and public recommendations to inform how we release these results.
github.com/openai/math
We’re releasing a broad range of new mathematical results produced by an internal frontier model.
We’ve been consulting with the independent Advisory Group on Mathematics and Artificial Intelligence at the Institute for Advanced Study, and we have drawn on their advice and public recommendations to inform how we release these results.
github.com/openai/math
this is pure f*cking treasure
A Stanford AI research group found how to orchestrate Claude Opus 5.5 and GPT-6.1 Sol together, and it completely breaks the search scaffolding wall
most developers try to combine frontier models by chaining prompts in one context window or hardcoding rigid evolutionary loops. you burn tokens on context bloat and freeze models into fixed search rules that out-date themselves within 5 iterations
Stanford's architecture eliminates human-designed search scaffolding and splits the cognitive stack:
> search director: Claude Opus 5.5 plans the search, querying a persistent idea-graph where MAP-Elites and MCTS reduce to single Cypher queries
> candidate proposer: GPT-6.1 Sol explores high-entropy code variations inside isolated execution sandboxes
> zero context bleeding: sessions reset after each iteration to prevent prompt bloat while the graph stores lineage
> evaluator isolation: candidate code never touches the scoring process, stopping reward hacking and test leakage cold
> meta-agent distillation: an offline meta-pass extracts verified lessons and updates search guidance across branches
the benchmark metrics outclass standard discovery baselines:
> 3.2x lower model spend than fixed evolutionary frameworks
> 1st place rank across 7 competitive AtCoder heuristic contests against human competitors
> beats published SOTA on Anthropic kernel builder and 11 mathematical optimization tasks
> 0% reward hacks: candidate-controlled metric tampering eliminated
Opus directs the search graph. Sol explores the code
you stop writing rigid search harnesses. you let frontier models own the discovery loop
Aligorithm 🇮🇷🇱🇺 retweeted
Handbook on Understanding Harness Engineering for AI Agents [48-page PDF]: drive.google.com/file/d/1PT-…
Aligorithm 🇮🇷🇱🇺 retweeted
Transformer and Mixture of Experts, explained visually!
Mixture of Experts (MoE) is a popular architecture that uses different experts to improve Transformer models.
Transformer and MoE differ in the decoder block:
- Transformer uses a feed-forward network.
- MoE uses experts, which are feed-forward networks but smaller compared to those Transformer.
During inference, a subset of experts are selected. This makes inference faster in MoE.
Also, since the network has multiple decoder layers:
- The text passes through different experts across layers.
- The chosen experts also differ between tokens.
But how does the model decide which experts should be ideal?
The router does that.
It is a multi-class classifier that produces softmax scores over experts to select the top K experts.
The router is trained with the network, and it learns to select the best experts.
But it isn't straightforward.
There are challenges!
Challenge 1) Notice this pattern at the start of training:
- Say, the model selects "Expert 2"
- This expert gets a bit better
- It may get selected again since it's the "best"
- It learns more
- It gets selected again in the next iteration
- It learns more, and so on!
This means many experts can go under-trained due to the overselection of a few experts!
We solve this in two steps:
- Add noise to the feed-forward output of the router so that other experts can get higher logits.
- Set all but the top K logits to -infinity. After softmax, these scores become zero.
This way, other experts also get the opportunity to train.
Challenge 2) Some experts may get exposed to more tokens than others, leading to under-trained experts.
We prevent this by limiting the number of tokens an expert can process.
If an expert reaches the limit, the token is passed to the next best expert.
Overall, MoEs have more parameters to load. But a fraction of them are activated during inference. This leads to faster inference.
Mixtral 8x7B and Llama 4 are two popular MoE-based LLMs.
Have you used MoEs in production yet?
To dive deeper into how MoE inference works in production, we wrote a full article covering token dispatch, grouped expert computation, model-weight memory, multi-GPU communication, expert placement, load imbalance, and performance diagnosis.
Read it below.
Aligorithm 🇮🇷🇱🇺 retweeted
(1/12) New Paper 📄
Linear-time attentions are reaching frontier scale, their fixed-state memory, however, still saturates as context grows, because all of its capacity is exposed from token 1. Early tokens face no pressure to compress, so they take far more of that capacity than they need. Later tokens inherit a state that is already full.
We introduce incremental memory activation: a fixed-size memory should not expose all of its capacity at once. It should schedule how much is live as the context grows, imposing a bottleneck early that forces the model to summarize rather than memorize, and unlocking fresh capacity later so new information has somewhere to land that isn't already written.
Proteus is the simplest instantiation of that idea. We partition the memory into E blocks and unlock them one at a time as the context advances, gating both reads and writes so locked blocks are neither retrieved from nor updated. The state itself never grows; only the active fraction of it changes. It comes at no extra cost and improves average performance on language modeling and commonsense reasoning (+0.37–1.05 avg. accuracy points). More interestingly, it yields significant gains in long-context handling: up to +8.4 NIAH points at 2× the training context length.
Read more background/method/results below 🧵
Aligorithm 🇮🇷🇱🇺 retweeted
After a long journey through review, our paper is finally out in Nature Communications.
We started with a simple problem: The visual cortex is strongly modulated by movement. So how can it represent the visual world without movement interfering with everything? 🧵
Aligorithm 🇮🇷🇱🇺 retweeted
A speck in a dish—that’s all the nervous system of the fruit fly Drosophila melanogaster looks like to the naked eye.
But look closely enough, and it resolves into a network of 166,700 nerve cells connected through 124.2 million synapses.
The intricate map—called a connectome—has now been published, marking the end of an ambitious 20-year research project. Learn more: scim.ag/4yoaEEc @NewsfromScience
Aligorithm 🇮🇷🇱🇺 retweeted
“Recurrent Looped Transformer”
This paper makes the decoder recurrent across every prompt and response token, while a causal encoder provides reusable global KV memory.
Longer sequences then create deeper latent computation paths without adding more physical layers, while keeping the same state transition across pretraining, inference, and RL replay.
alphaxiv.org/abs/2609.recurr…
Aligorithm 🇮🇷🇱🇺 retweeted
👋 Say hello to faster structure prediction
NVIDIA BioNeMo Inference Runtime is in public beta. This open, PyTorch-native library speeds up biomolecular inference on NVIDIA GPUs.
Optimize models including Boltz-2, OpenFold2, and Protenix v2 with specialized kernels and, where supported, CUDA Graphs - then scale with Ray-powered GPU replicas.
🙌 Huge thanks to our collaborators at @apheris_AI, @AurekaBio, @Biomap_IMI, @boltz_bio, @dataiku, @UWproteindesign, @Latent_Labs, MoleculeMind, @nebiusai, @openmsf, @open_fold, @proximabio, @SandboxAQ, @Terray_Tx, and @Xaira_Thera for partnering with us on this work.
📃 nvda.ws/46PDmlL






































