NN_pdns

[NN_pdns @Tr0Van79490]

@usmanjramay @theo I’d also try Luna doing the work with Astra as a CC-style adviser. I haven’t tested it, so that’s only a hypothesis. It might help, but I’m skeptical of Luna’s ability to build a sound plan and choose the right implementation, even with stronger advice available.

[NN_pdns @Tr0Van79490]

@usmanjramay @theo In our run, Luna was cheap; coordination wasn’t. Astra spent extra turns reconciling outputs, fixing shared-contract mismatches and integrating changes. Splitting tightly coupled work added work for the lead. I’d delegate only clearly independent pieces.

[NN_pdns @Tr0Van79490]

@usmanjramay @theo In our test, Astra/high + 3 Lunas cost an estimated 2.74x as much and took 1.67x as long as Astra/high alone. Astra drove 97% of cost. Cheap workers aren’t cheap workflows. Let Astra own connected work; review independently. Keep Luna for narrow, independent tasks.

[Rhys @RhysSullivan]

My rough prediction here is there's going to be two types of companies:

1. Companies that are ok with basically being an API - they expose an MCP, skills, embrace your agents

2. Companies that charge a ton for API access, try to get you using their own agents,

Companies will gravitate to #2 because being API only is scary / feels very replaceable opening opportunities for #1 companies to replace them because they're more agent native

I don't have a good answer for what the moat is for #1 companies but it's how I want to be using software

[SaltyAom @saltyAom]

Ok, I'm going to be annoying here

But what's stopping Node.js from implementing a native HTTP server based on Web Standard Request/Response?

Like really? What's stopping it?

It's very clear the industry has moved into this

Runtime: Bun, Deno, Workerd/Cloudflare Worker, Vercel Function, Netlify Edge Function, Fastly Compute, Supabase Edge Function, even in your browser via Service Worker

Meta framework: Nextjs, Nuxt, Angular, SvelteKit, Tanstack Start, Astro, Remix, Waku

Even backend frameworks: Hono, Elysia, H3, every single Deno/Bun/Cloudflare Worker framework

Every single one uses Web Standard Request/Response, but the only major runtime that doesn't support it is Node.js?

I would urge that not implementing it is hurting the ecosystem

It makes the library/framework author have to implement their own adapter to convert from Node IncomingMessage/OutgoingMessage to Web Standard Request/Response just for the user to use it properly in a runtime that doesn't support it as an exception

It noticeably adds unnecessary work to maintainers and additional overhead in both compute and memory usage for YOUR servers

If you are using a meta framework, you are having a performance degradation compared to what it should be because Node.js simply decided not to implement this specific feature over the past years

"Oh but it is slow"

Implementing it in runtime native code has many more optimization options available than in userland, like lazy initialization, like how Deno does

And it can't possibly be worse than every framework paying adapter cost today

"Oh but that would be a breaking change"

No, Web Standard Request/Response exists but is just never used outside of fetch

http.createServer doesn't need to be removed; just create a new function that doesn't intersect with it, and that's just literally it

Node.js was even on the WinterCG committee (now WinterTC) to draft this standard, just to implement the bare minimum for fetch and not an HTTP Server?

Like come on

I'm willing to bet if you ask a maintainer of a framework that supports API routes how they feel about this, every single one will say they're not happy or at least annoyed

Personally, it felt like it's starting to get from the understandable zone into a really questionable zone

I know how frustrating it is for maintainers to get a request to support this or that, as I myself also don't like one either

But come on, when there's a standard already agreed on and used by everyone for years that even you yourself helped draft but just decided not to use it, you can't expect people not to complain about what makes their work harder

Do I have to draft a page requesting support and ask for the author of each framework/runtime to sign so we can have the evidence that the majority library/framework wants it?

Or do you need help to draft an API or implementation?

I'm willing to bet that many people would want this feature natively supported on Node.js, even I would be willing to help with it where I can

[Psyho @FakePsyho]

FYI, as expected, this looks like a complete slop (not only the posts but the whole project)

For people lacking context: The Witness is a game that has a bunch of logic puzzles where clues are abstract and you have to discover their meaning through experimentation. You learn those rules by experimenting with the puzzles - every time you submit an incorrect solution, you get feedback for all of the clues that were not satisfied.

Based on the public repo, this "benchmark" more or less reuses the same set of mechanics (clue types). But when agents submit solutions they don't get this feedback about violated clues.

In other words, this was supposed to test rule discovery, but (a) essentially all of the rules are already widely available since The Witness is a very popular game (b) the basic mechanism for learning the rules is completely missing. Agents will either immediately know the rules, or will have no way of finding them.

Chat has found many other issues in the repo (like missing visual representation of some of the rules, which makes some puzzles potentially impossible), but this one invalidates the whole premise behind the benchmark.

annoying af, please stop spreading slop

[NN_pdns @Tr0Van79490]

@AdamHoltererer Yes, because it’s not a fast mode, but a «priority» mode, tell him about it and he’ll understand.

[LaurieWired @lauriewired]

How do you protect an immensely vulnerable system against a stronger, even God-like adversary?

Well, you use a Shadow Server of course.

Power plants have lots of interesting ideas.

The NIST published a “Situational Awareness For Electric Utilities”. One fun concept is when you absolutely *cannot* protect a system, (imagine a Window XP box that controls the turbines), but still need to interact with it, do the following:

1. Create an (optical) one way diode to another machine
2. Said machine becomes the “shadow historian”
3. All queries interact with shadow data.

To *write* to the vulnerable box, a “protocol break” is required. The data model has to be converted.

In other words, you have a middleman server with a drastically different OS, communication protocol, auth, etc. Conceptually, it’s known as a virtual patch; although the underlying legacy software hasn’t changed, data conversion from say, an HTTP API to an ancient serial protocol.

The patch blocks, or is otherwise physically incapable of satisfying known vulnerability preconditions.

Neat to think about, there’s nothing really preventing you from doing this in your own homelab!

[NN_pdns @Tr0Van79490]

@chokudai It’s important to remember that this enabled tour1st to adopt a bold strategy to ensure victory - solving a problem worth 2,500 points + 900 to exceed ABC’s total score by 100. This was the most difficult problem solved under time constraints.

[NN_pdns @Tr0Van79490]

@thsottiaux On the usage limits page in Codex, the prices in “credits” for Terra and Luna tokens have been accidentally swapped.

[NN_pdns @Tr0Van79490]

@FakePsyho I'm a complete layman on this subject and can't say for sure, but it seems that LLM submitted a new piece of code every time (without rollbacks), except for a couple of times.

In addition, there was a better version of the solution from LLM (I may be wrong in my conclusion).

[Matt Pocock @mattpocockuk]

This is a PRD based on a multi-day /wayfinder session

Look how detailed it is

Look how every assertion is linked back to the session where it was decided

Secondary source -> Primary source

Beautiful

https://t.co/AMVKBNJq6X

[VulcanBench @VulcanBench]

Okay, I'm just going to come out and say it. We have to start sharing token use alongside model performance.

I don't think benchmarks are as useful if you see one model is 6% more accurate than another, but don't know if one uses 600% more tokens than the other.

A good model should have a balance of accuracy, coupled with strong token use.

This is why I share this in all of my benchmarks. Take this one from yesterday. If you just looked at the results you would say, oh GLM 5.2 High ties Fable 5.2 Low and Sonnet 5 High.

But the reality is, to tie them both, it had to use 7,628% more tokens and the cost, 596% more.

Most benchmarks would just show all these models against each other with one accuracy score. This doesn't tell the whole story.

We can do better.

[harrrshall @HarshalsinghCN]

introducing tinyrouter

i reverse engineered the routing architecture behind Skana AI's Fugu and built replication for open frontier models.

it's a tiny ~10K parameter LLM router that learns which model to use and what role it should play for every question.

the goal was simple: beat every individual model by routing each task to the right specialist instead of relying on a single LLM.

https://t.co/pjHHk1QS9m

a few interesting findings:

• routing only helps when the models have complementary strengths. if every model performs similarly on a benchmark, a router has almost nothing to optimize.

• on MMLU, the router beat every individual model. on math, it matched the best model because the pool had very little observable diversity.

• warm-starting the router and shaping the evolutionary reward improved training, but we don't claim a real gain yet because evaluation variance was too high. more rigorous experiments are needed.

[Leo - 15 y/o founder @leodev]

Technical question for a project I'm building.

How would I store .env variables securely for users?

Storing it in a database with encryption still seems wrong, but that's what my best solution is right now but I want my users not to worry at all about it so what should I do?

[Sander Dieleman @sedielem]

Here's a cool piece of LLM lore: the original scaling laws were wrong due to a bug, which probably led to a lot of wasted compute on oversized undertrained models 🫣 (and that was before we even started properly accounting for inference cost!)

[Sanika Suryawanshi @Sanika_0305]

We got a new HTTP method before GTA 6. 💀

After decades of the same core HTTP verbs, we're finally getting a new one: QUERY.

It was published as RFC 10008 on June 15th 2026.

[Lee Robinson @leerob]

Are current LLMs incompatible with great creative writing?

I can't tell if it's cope or not, but it seems like even with the best models, I still can't get them to write like humans would.

For coding, there is a verifiable reward like it compiling or tests passing. But for creative work like writing, it's much more subjective.

I have struggled to prompt / harness the models to write truly amazing work. They are fantastic for spell checking, grammar suggestions, and taking on different personas to read and critique work.

Maybe it's because I'm only doing nonfiction, and to write something top 0.1% means that you need to think over a long horizon and develop an interesting insight about the world. Great writing is clear thinking.

I've even asked models to try 10 different versions of a blog post, then have a council of models grade and critique the results and pick the best parts... and still I end up with this lowest common denominator slop.

Skill issue? Someone show me the way.

[alex fazio @alxfazio]

if you’re into harness engineering, i strongly recommend looking into arc agi winning harnesses. they clearly illustrate what works from first principles, what is bs, and why a lot of current harness design is overfitted to benchmarkmaxx

[青龍聖者 @bdsqlsz]

GPT-5.5 is actually “getting dumber” — it may be getting silently truncated:
The system prompt command model provides data every 30s, which causes the model to automatically truncate tokens after a length(usage.output_tokens_details.reasoning_tokens == 518 * n - 2).
fix way ↓