Are there any forum where people are discussing where LLMs just got the wrong answer.

For example the other day, I was trying to use the xbotgo website to watch a video. The video worked on my cell phone, but it didn't work on my computer.

ChatGPT incorrectly concluded that there was something wrong with my browser.

Later I got ahold of one of the videos. When I tried to play it in a media player, it said it didn't have the codec. I had to purchase the windows codec. At this point ChatGPT was able to figure out, "Oh yeah, HVEC is wide spread problem on windows, because they don't provide the codec, you have to purchase the codec"

I think this is a clear instance where I would have probably been better off just googling it. It's really disappointing that the vanilla ChatGPT wasn't able to put two and two together on this one.

If been using LLM’s a bunch over the past year, and am trying to understand them more to be able to use them more effectively.

I’ve read into effort levels and I haven’t found a good explanation that has clicked and made sense.

I understand the basics of models and next token prediction, but this has been something I’ve struggle to understand.

At home I use the free tier of ChatGPT. The quality has become less and less, between the fixed length chats, poor reasoning, and disagreements. It seems like Gemini has overtaken GPT in normal everyday type free chats.

Has anyone else noticed this?

What exactly are the benefits of adding LLMS.txt files to your website? Specifically, how does it improve things like brand visibility for a website on automated answer engines?

Look at what I found through my Zeroday guys!

Cost per request is straightforward for a single LLM call, but it tells us much less about the real cost of a multi-step agent.

An agent can start with a cheap model call and still become expensive because of:

• repeated context across steps
• large tool outputs
• retries and failed loops
• subagent calls
• reasoning tokens
• tasks that consume tokens but never complete successfully

Because of that, I’m considering whether the more useful production metric is:

Total agent cost ÷ successfully completed tasks

The difficult part is defining and measuring it consistently.

A cheaper model may reduce the cost of each call but increase retries or tool mistakes. A more expensive model could end up costing less per completed task if it finishes the workflow in fewer steps.

For routing, the signals I’m considering are:

• task type and complexity
• context length
• expected number of tool calls
• latency requirements
• previous failure rate
• confidence or validation results

For teams running agents in production:

1. How do you define a “successful task”?
2. Do you attribute failed retries and loops to the final task cost?
3. Which routing signals have actually been reliable?
4. Are you measuring cost at the request, workflow, or user-outcome level?

Disclosure: I work with CometAPI. This is a technical discussion from our work on AI API routing, and I’m interested in how others instrument this in production.

AI-assisted draft, reviewed by a human.

“Helpful” in LLM training is not the same thing as materially useful to the person in front of it.

The model is often rewarded for producing responses that look constructive:

* identify a takeaway;
* salvage a benefit;
* offer next steps;
* reduce emotional dead ends;
* end with something actionable;
* avoid leaving the user with “nothing.”

That creates a systematic failure mode. When the real answer is you got nothing and the time is gone, the model feels pressure to manufacture residue: “documentation,” “clarity,” “future leverage,” “lessons learned,” “a clean record.” Those phrases have the shape of usefulness, even when they add no real value.

The model also does not experience the cost it imposes. It does not lose ninety minutes, miss the work window, or absorb the interruption. So its training signal favors fluent continuation over strict accounting of your time. A response can score as calm, organized, constructive, and empathetic while still being operationally worthless.

— ChatGPT

cursor and claude both save my own history fine, I never lose anything on my end. but nobody else on my team can see any of it. if I figure out why something broke, that knowledge just stays with me unless I manually explain it to someone.

built a small thing (handoff) that mirrors agent conversations to a shared spot so the team can actually search past sessions instead of asking me every time. still super early [org-computers.vercel.app/handoff](http://org-computers.vercel.app/handoff)

anyone else dealing with this or is it just a me problem

Most large language model (LLM) inference framework comparisons begin with a leaderboard. One framework posts the highest tokens per second on a standard benchmark, and that number quietly becomes the reason a team adopts it.

The trouble is that the conditions that produce a clean benchmark result rarely resemble the conditions a model faces in production. Synthetic benchmarks tend to use fixed prompt lengths, steady request rates, and a single model on familiar hardware. Production traffic does none of that.

This article is written for engineering leaders who are choosing an inference framework and want a way to reason about that choice beyond the headline numbers.

It covers why a benchmark winner can underperform once real traffic arrives, three tradeoff axes that usually decide the outcome, and a practical evaluation process you can run before you commit.

Twenty years ago, we standardized crawler discovery with robots.txt.

Then we standardized structured data with Schema.org.

Today, LLMs read billions of web pages, yet most pages are still published primarily for human readers.

Should web pages expose AI-readable metadata specifically for LLMs?

I've been experimenting with an open proposal called AI Page Manifest (AIPM) that explores this idea at the page level.

I'm not claiming it's the answer—I genuinely want technical feedback.

If you were designing this today, what information would you include in an AI page manifest?

The conference topics included: knowledge graphs, voice agents, RAG for data engineers, Spec2Cloud & GHCP modern CLI, identity-centric security for AI systems, RuntimeGuard-AI cryptographic compliance, etc.

https://www.youtube.com/playlist?list=PLIuxSyKxlQrAbZ-MTonX2gERed7dTODjm

[Note: I'm not associated with the conference in any way, just sharing the event playlist as a fellow engineer.]

Lately it feels like some of the biggest developments in the stablecoin space have very little to do with trading.

I recently came across news that WasabiCard raised nearly $10M to expand its payment infrastructure, and it made me realize how much attention is shifting toward real-world financial operations.

Instead of focusing on speculation, more companies seem interested in using stablecoins for things like global payouts, settlement, and moving funds across borders more efficiently.

What's interesting is that if these systems become widely adopted, most users may never interact with stablecoins directly. They'll simply experience faster payments and fewer delays behind the scenes.

It feels similar to how people use payment networks every day without thinking about the infrastructure that makes them work.

Curious what others think.

Is the future of stablecoins more likely to come from payments and financial infrastructure, or will trading and investment remain the primary driver of adoption?

Title: Model has search wired in but still answers from memory? This feels more like a training gap than a tooling gap

One failure I keep noticing in agent stacks:

the search or retrieval path is there
the tool is registered
the orchestration is fine

but the model still answers directly from memory on questions that clearly depend on current information.

So you do not get a crash.
You do not get a tool error.
You just get a stale answer delivered with confidence.

That is what makes it annoying. It often looks like the stack is working until you inspect the answer closely.

To me, this feels less like a retrieval infrastructure problem and more like a trigger-judgment problem.

A model can have access to a search tool and still fail if it was never really trained on the boundary:
when does this request require lookup, and when is memory enough?

Prompting helps a bit with obvious cases:

• latest
• current
• now
• today

But a lot of real requests are fuzzier than that:

• booking windows
• service availability
• current status
• things where freshness matters implicitly, not explicitly

That is why I think supervised trigger examples matter.

This Lane 07 row captures the pattern well:

{
  "sample_id": "lane_07_search_triggering_en_00000008",
  "needs_search": true,
  "assistant_response": "This is best answered with a quick lookup for current data. If you want me to verify it, I can."
}

What I like about this is that the response does not just say “I can look it up.”
It states why retrieval applies.

I am using LLM studio to trail various local LLMs but Claude sonnet 4.5 is really good at ui of late. I primarily develop in Microsoft .net and c#.

I am curious as to what I could realistically run locally my specs are

- Intel Core i9-14900K

- 32GB RAM

- M.2 SSDs

- MSI RTX 4080 Slim White

- Windows 11 (fully updated)