Ss

[Ss @NorisVello]

ราคา4,000 ส่งต่อสิทธิ์ VIP ทั้งหมด
การเข้าชมรอบซ้อม จาก FTISLANDS
ตำแหน่งนั่ง A3 โซน AH(แถวที่ 8 จากหน้าเวที) ใกล้โซนA2เห็นกลางเวที
ทัก dm หรือเฟสได้
#RE_FTISLANDinBKK
#RE_FTISLANDinBANGKOK

[Ss @NorisVello]

ปล่อยบัตรโซน A3 แถวนั่งAH ฝั่งที่ติด A2 รายละเอียด DMได้เลย ปล่อยต่อ 5000 พอดีได้บัตรอีกที่นึงเลยปล่อยต่อราคานี้ อยากให้แฟนๆไปดูกันเยอะๆนะ
#RE_FTISLANDinBKK
#RE_FTISLANDinBANGKOK

[alphaXiv @askalphaxiv]

"Q-Learning with World Models"

World models can improve RL, but training directly on imagined rollouts compounds model errors into the policy very easily.

This paper instead uses the world model only at decision time, searching over short imagined futures while keeping Q-learning trained entirely on real transitions.

This improves sample efficiency and performance across the board, and even outperforming strong model-free and model-based RL baselines.

https://t.co/NFSioCmUkA

[Akshay 🚀 @akshay_pachaar]

https://t.co/3DkJWEFHaJ

[Akshay 🚀 @akshay_pachaar]

RAG vs. CAG, clearly explained!

RAG is great, but it has a major problem:

every query hits the vector DB. even for static information that hasn't changed in months.

this is expensive, slow, and unnecessary.

Cache-Augmented Generation (CAG) fixes this by letting the model keep static information in its key-value (KV) memory, which is what the model builds internally for every token it reads.

in fact, you can combine RAG and CAG for the best of both worlds.

here's how it works:

RAG + CAG splits your knowledge into two layers.

↳ static data (policies, documentation) gets cached once in the model's KV memory

↳ dynamic data (recent updates, live documents) gets fetched via retrieval

you get faster inference, lower costs, and less repeated work.

the trick is being selective about what you cache.

only cache static, high-value knowledge that rarely changes. cache everything and you'll hit context limits. separating "cold" (cacheable) and "hot" (retrievable) data keeps this system reliable.

you can start today. OpenAI and Anthropic already support prompt caching in their APIs.

one thing to know before you scale it.

prompt caching matches on an exact prefix, byte for byte. your cached layer only gets reused when it sits at the very front of the context in the same order every time.

↳ reorder two cached policy documents and both turn into a miss

↳ cache document A alone and document B alone, then query both, and the second one misses because the model computed its cached state without ever seeing the first

in production this looks like a small fraction of your cached blocks serving almost all the hits. the rest just sits there.

the way out comes from how attention behaves. tokens attend mostly to their own local neighborhood, and only a few reach across document boundaries. CacheBlend recomputes those few and reuses everything else from the separately cached documents.

multi-document queries run two to four times faster, quality holds, and order stops mattering.

it ships in LMCache, which is fully open source.

repo: https://t.co/TXlaLLu04a

(don't forget to star 🌟)

below, i have quoted my article on KV cache management. it covers where prefix caching stops working and how a proper caching layer fixes it.

give it a read.

cheers! :)

[alphaXiv @askalphaxiv]

"Mathematics in the Age of AI"

In an age of abundant AI-generated proofs, human understanding may become more valuable than proof generation itself.

This new paper from Terence Tao argues that AI could make solving hard math problems much cheaper and faster, but at the same time, creates a new problem.

If AI can generate thousands of correct proofs, mathematicians can’t possibly read, understand, verify, and teach all of them.

So the scarce resource in mathematics shifts from finding proofs to making sense of them.

The important work becomes deciding which results matter, explaining the key ideas, connecting them to existing theory, and turning them into knowledge other mathematicians can actually use.

https://t.co/otIGL0SQrq

[elvis @omarsar0]

Very interesting new work from Microsoft.

(bookmark it)

This work is related to this emerging theme of leveraging harnesses for model post-training.

Modern agents run inside a harness that owns tools, context, and control flow. When you train them, the harness owns the environment loop and the trainer only sees LLM request and response pairs.

How it works.

Agent Lightning v1.0 connects any harness to RL through an endpoint proxy in about 3,500 lines, then works through what breaks in that setup, retokenization, sample merging, advantage calculation, loss normalization, and backend scheduling.

Using 6K training examples and modest compute, it moves Qwen3.5-9B on SWE-bench Verified from 41.8% to 56.4%.

Paper: https://t.co/VFomMjMi5Q

Track more trending AI papers in our academy: https://t.co/1e8RZKs4uX

[Ilir Aliu @IlirAliu_]

MIT Press published a robotics textbook.
Then put it on GitHub for FREE. 📌
"Introduction to Autonomous Robots" covers everything:

kinematics, sensors, actuators, motion planning, localization, computer vision, and neural networks... from mechanisms all the way to algorithms.

It's written for undergraduates. Which means it's actually readable.

Most robotics textbooks assume you're already deep in the field. This one builds everything from the ground up, step by step, with real examples. Stanford's Mac Schwager called it "much-needed" (because it genuinely is).

Four professors at the University of Colorado Boulder spent years building it from lecture notes. MIT Press published it. Then they open-sourced the whole thing under Creative Commons.

PDF. Free. GitHub.

If you're trying to understand how autonomous robots actually work (not just the frontier research, but the foundations), this is where to start.

📌 [https://t.co/bw8zoK8MmB]

Share this with your fellow roboticist!

——

Weekly robotics and AI insights.
Subscribe free: https://t.co/9Nm01QUcw3

[Kirill @kirillk_web3]

A Chinese developer just explained the shift from Loop Engineering to Graph Engineering better than anyone.

most people are still building agents the way that's about to be obsolete.

> why single-agent loops break and go "goal blind"
> the 4 parts of a graph: nodes, edges, state, policy
> 3 topologies that run everything: diamond, supervisor, pipeline
> Anthropic's 5 official workflow patterns

the punchline: it's not how many agents you run. it's the determinism you build with verifiers, code fallbacks, and reality anchors.

I broke the same architecture down with Kimi K3. Full A-Z guide below.

[Léo @LeoKharon]

Robotics deep dive: TENDON-DRIVEN HANDS

There is no room in a finger.
That one constraint drives the architecture most serious robot hands have converged on: take the motors out of the hand entirely and pull the fingers with cables.

Tesla is the loudest example.
Optimus has pulled its fingers with cables since the first hand in 2022: six actuators, spring return, eleven joints.
What moved was the motors: they sat in the hand back then, and the newer hand puts them up in the forearm -> same transmission, relocated.
Shadow Robot has built hands this way for two decades.
NASA's Robonaut 2 packed all 18 actuators into the forearm and ran the cables through the wrist.

The reason is mass, and headroom.
A motor at a finger joint is mass at the fastest-moving end of the robot, and the finger caps how big that motor can ever be.
Move it to the forearm and the finger gets light and thin, and the motor can be as large as the forearm allows.

A cable can only pull, it cannot push.
So every joint needs either a second cable pulling the other way, or a spring to snap it back.

But it actually does not need two cables per joint.
The real floor is one of the oldest results in the field: Salisbury and Mason, 1985: an N-joint tendon mechanism needs a minimum of N+1 cables.
Robonaut 2 drives a 3-joint finger with 4 cables and a 4-joint thumb with 5.
Shadow spends the full two-per-joint anyway and runs about 40 cables.
That gap is a design choice about how much space you're willing to give up, not a law.

However, cables stretch, saw against their guides, and go slack.
Robonaut's team picked Spectra for its strength and found its creep was incompatible with their actuators.
They rebuilt the tendons as a Teflon-Vectran braid, 1.2 mm, 181 kg break strength, rather than change the architecture.
ETH's open-source ORCA hand, published last year, says it plainly in its own limitations section: prolonged use requires manual re-tensioning.

Friction in the routing eats an unknown fraction of torque on the way.
Shadow puts a force sensor on every tendon and admits in its own spec that the sensors are zeroed but never calibrated: a reading of zero means the two cables in a pair are equal, not that the force is known.

Which is what makes 1X the interesting one.
Their published answer to that problem is to barely gear the thing: NEO's hand runs what they call quasi-direct-drive tendons at roughly 5:1 to 15:1, with the motors in the forearm pulling through the wrist. Low gearing is the same move the field made at the ankle and the knee, and it buys the same thing here, a joint you can push back on.
1X claims all 25 degrees of freedom are force-controlled and fully backdrivable, 22 through the fingers and palm plus 3 at the wrist, with 3.5 Nm at the thumb base and 45 N at the fingertips.

You get light, fast, human-shaped fingers, and you accept a transmission that stretches, wears, and is honest with you only in proportion to how little you gear it.

[Fanny @fanny_riyanti]

Paradise - full song
#FTISLANDwithSymphony

[ᴊᴇᴀʙ ₍^. .^₎⟆🍀 @katsumiooi]

อิจฉาคนที่ไปดูเอฟทีเล่นกับวงออร์เคสตราอะ ต้องสนุกแน่เลย 😭😭😭

[Kirk Borne @KirkDBorne]

The Mathematics of Large Language Models — A Readable Guide to LLMs, Transformers, Diffusion, Neural Networks, and Generative AI: https://t.co/LpHsnlyQme

[macaroni 🍽 @roongie_JS]

เอารูปครอบครัวไปอัดเพิ่มมา ฟตก.แบบ 4 : All 😆

และขอยืม กอว. พรีม่าใส่ในกรอบด้วยนะคร้าบ 💛✨

#FaTeinBANGKOK #FTISLAND

[Md Ismail Šojal 🕷️ @0x0SojalSec]

MIT researcher drops out of his PhD. Then dropped a full roadmap to emulate a human brain on 50,000 H100s.

He mapped the entire path: 302-neuron worm to 86-billion-neuron human
Connectomics cost is already $100 per neuron.
The only real blocker left is data acquisition.

Reason: AI is moving too fast.

His alternative? A concrete plan to run a full human brain on 50k H100s in under 10 years for $10B,
From C. elegans to digital humans the path is now an engineering problem, not science fiction.

[beamnxw ./ @beamnxw]

This paper is f*cking brilliant

A computer science survey mapped 150+ agent memory architectures across 90 pages to build self-evolving long-horizon agents

The result: a 3D taxonomy showing action-based memory and self-evolving structures boost long-horizon retention by 50%

The crazy part is memory is no longer just a passive database lookup

It also trains models to execute tool actions, update parametric weights, and consolidate episodic traces into skills

Most memory surveys analyze static database retrieval

This one maps the entire self-evolving agent operating system

Read the complete paper + article below

Bookmark it for future reference

[.ϻöժ☻ @ModNoiL]

คือดูไป10รอบละ5555555555 so cute 🤏🏻🤏🏻 @skullhong

[Akshay 🚀 @akshay_pachaar]

NVIDIA researchers built a new transformer variant.

One small change to the layers made:

- decoding 1.7x faster
- long-reasoning accuracy up 6.5 points

In a typical transformer architecture, every attention layer computes Q, K, and V.

NVIDIA's tweak adds a fourth projection, which predicts what the next layer will need.

To understand why they did this, let's first see what happens in a Transformer architecture during inference right now.

Sparse attention was an attempt to handle long-context inference. Instead of attending to every cached token, modern designs score the KV cache in blocks, keep the top-k, and attend only to those.

That cuts attention compute and bandwidth, but this still leaves us with two problems.

> First, the KV cache still grows with every generated token.

At 100K+ context, it no longer fits in GPU memory and gets offloaded to CPU RAM.

Now every layer must first copy its selected KV blocks from CPU memory back to the GPU. That copy is slow, the GPU sits idle while it waits, and the stall repeats at every layer of every decode step.

> Second, the selection step itself is not free.

Standard selectors score every candidate block with every query head in a GQA group (grouped-query attention, where several query heads share one KV head), then softmax each head's scores and sum them across the group.

During decode, the sparse attention itself is cheap because there is only one query token.

But the expensive part is deciding which blocks to attend to, and that cost keeps growing with context length.

Both problems trace back to the same design in today's sparse attention methods, i.e., the attention query drives the block selection.

Selection needs the query vector Q, and Q only exists once its layer is already running. By then, it's too late to fetch anything early.

The query also drags its multi-head layout into selection, so all that scoring computation runs just to make one top-k decision.

A recent paper from NVIDIA and MIT called SparDA breaks this coupling with one architectural change.

Each layer now emits four projections instead of three:

↳ Q, K, V, and a Forecast.

The Forecast from layer L predicts which KV blocks layer L+1 will need.

Layer L+1's own query performs the sparse attention over those selected blocks.

This one change fixes both problems.

Since the next layer's block set is known while the current layer is still computing, the runtime fetches those blocks from CPU memory on a separate CUDA stream.

The copy overlaps with the current layer's compute, so the GPU no longer waits for it.

And since the Forecast is separate from the attention query, it doesn't need one score per query head.

SparDA uses one Forecast head per GQA group, which removes the per-query-head scoring loop and skips the softmax step entirely.

DeepSeek did something similar in DSA, where a small indexer picks important tokens instead of the query doing it.

SparDA applies the same idea to blocks and adds the prefetch angle that DSA doesn't touch.

The cost of the change is small.

The Forecast adds just 33.5M parameters on an 8B model (0.41%), and only those projections are trained, using a KL loss that matches the original selector's block distribution.

On MiniCPM4.1-8B and NOSA-8B, accuracy matches or beats the sparse baseline, with NOSA-8B gaining +6.5 on long reasoning.

Prefill runs up to 1.25x faster and decode up to 1.7x faster than the sparse offload baseline.

There's one more benefit.

Because prefetch hides the offload cost, most of the KV cache can live in CPU RAM, and the freed GPU memory fits much bigger batches, pushing decode throughput up to 5.3x over the non-offload sparse baseline.

That said, this lookahead will only pay off during decode with CPU offload. During prefill, all keys already live on the GPU, so the gain there comes purely from the cheaper selection.

Here's the paper: https://t.co/wnMG6iRcv9

I wrote a first-principles breakdown of how the KV cache works. It walks through why the model stores keys and values at all, why the cache grows with every token, and a comparison of LLM generation speed with and without KV caching.

Read it below.

[Wayne @waynoir]

Anthropic engineer said:

“70% of our engineers are using self‑improving loops. Now everyone is building agentic Graphs"

in next 3 months, we’ll all be building graphs to orchestrate self‑improving agents. No more prompting

in 30 minute lecture, Anthropic engineer shows how to build a self-improving agentic workflow from scratch

Worth more than a $500 agentic course

Watch this video, then read the article below on how to become a graph architect

[maynie * @imayniez]

คือมองแค่ภาพประกอบเอ็มวี ไม่มีทางเดาได้แน่ว่าซาวด์เพลงจะเป็นแบบนี้ 55555555555555555555555 พี่คะ

[Morlex @0xMorlex]

Google just showed how AI engineers are moving from simple "RAG" to "graphs", memory and multimodal agents

• 15:32 - setting up the production agent stack
• 28:00 - turning disconnected data into a knowledge graph
• 41:00 - Graph RAG with semantic + hybrid search
• 58:00 - extracting graph context from images, text and video
• 1:09:00 - orchestrating specialized agents with ADK
• 1:20:00 - giving agents persistent memory across sessions

94-minute Google Cloud workshop, and it’s one of the clearest hands-on examples of the shift from ->

RAG → Graph RAG → Memory → Multimodal Agent Graphs.

The workshop uses Spanner Graph, Gemini, ADK and Memory Bank to build that stack.

Watch it today, then read the full “From RAG to Context Graphs” roadmap below.

[Sebastian Raschka @rasbt]

Whoa, Meta released a new open-weight LLM yesterday, something that hasn't happened since the good old Llama days.

Their Meta Muse Glimmer model is a 30B multimodal reasoning model with a Gemma-like architecture design. (“Glimmer” is probably a wordplay on “Spark,” the more likely capable model from which Glimmer was distilled. Muse Spark is only available through Meta’s Model API, though.)

Architecture-wise, here are some of the main points:

1. "Only" a 131k context window, compared to Qwen3.6 and Gemma 4, which support 2x that natively; it's reasonable, but maybe on the shorter end in the age of agent harnesses

2. It's a dense model, not a mixture-of-experts. (So, it's fairer to compare it to Qwen3.6 27B than Qwen3.6 30B-A3B.)

3. Hybrid attention with grouped-query attention (GQA) and sliding window attention (SWA); the SWA:GQA pattern is a 3:1 local:global ratio. Other models like Gemma 4, which uses similar components, have a 5:1 ratio for comparison.

4. It adopts gated attention for both GQA and SWA; gated attention has become quite common in recent months. It basically applies a sigmoid gate to the attention output to decide how much of the attention information enters the residual connection. The interesting point is that it uses relatively standard GQA and SWA rather than hybrid attention mechanisms such as Nemotron or Qwen3.6.

5. A very extreme GQA ratio: 32 query heads and only 2 KV heads; for comparison, Gemma 4 31B uses 32 Q / 16 KV in the local heads and 32 Q / 4 KV in the global heads. This means that Meta Glimmer has a very small KV cache.

Overall, the probably most similar architecture is Gemma 3 27B (including the Gemma-style pre/post RMSNorm placement) and Gemma 4 31B, but with some tweaks like SwiGLU instead of GeGLU activations, gated attention, and the more extreme GQA:SWA pattern mentioned before.

What stands out is its extreme KV-cache efficiency.
I.e., the KV CACHE / TOKEN ratios (in BF16) are:

- Muse Glimmer: 52 KiB (lower is better)
- Qwen3.6 27B: 64 KiB
- Gemma 4 31B: 840 KiB

Modeling-performance-wise, their own benchmarks show that it's mostly ahead of Qwen3.6. According to the independent composite benchmarks on the Artificial Analysis Intelligence Index, it's slightly behind Qwen3.6 (see figure below). So, a few days of using it will tell where it really ranks.

Overall, it looks like a solid model, particularly for agentic workflows. What stands out most is its very low memory footprint and also pretty fast prefill and decode speed. It’s also just great to see Meta releasing open weights again :).