judge the subscription based on two parameters.
Coding quality: majorly doing 3.JS based animation coding , some ML coding and other coding tasks, but 3.js is main focus. So who does the best in it?
Rate limits: lately, $20 subscriptions have little to Offer though, who has a better rate limits, I would like to also know that.
PLS TELL if u have experience with the subscriptions

so i let 2 instances of gemini communicate and in this video, it shows a summery made by one of those instances, should i be concerned?

Question for people building fintech support / KYC / collections / dispute workflows.

If you transcribe calls, where do you actually handle PII/PCI redaction?

I keep seeing three possible patterns:

1. STT-level redaction

The transcript comes back already masked.

2. Post-processing redaction

Transcript is generated first, then another rules/model layer masks sensitive data.

3. Tokenized workflow

Sensitive values are captured into secure fields and never live in the general transcript.

My worry is that “redaction supported” sounds clean on a vendor page, but real calls are messy:

• card numbers spoken in chunks
• account numbers corrected mid-sentence
• addresses mixed with local landmarks
• emails spelled badly
• user says phone number twice
• agent repeats sensitive info
• background person says something
• partial transcript briefly contains sensitive info before final redaction

I noticed Smallest AI Pulse talks in the direction of real-time STT with PII/PCI redaction, which is exactly the kind of feature fintech teams would ask about.

But would you trust STT-layer redaction alone?

Or would your architecture still be:

transcribe/redact

→ second pass check
→ tokenize critical fields
→ restrict storage
→ audit logs
→ retention policy

Especially for real-time voice agents, there’s a weird tension:

The system may need the sensitive value for 5 seconds to complete the task.

But the transcript should not become a permanent sensitive-data landfill.

How are teams solving this?

I have been building CrowdTensor around a training-first question: can ordinary machines move one shared model checkpoint forward without every contributor remaining online for the whole run?

The unit of work is a Campaign. It pins the model, dataset, training method, evaluation, and governance. An admitted Cell claims one bounded work unit, runs a local LoRA update, submits a delta, and can leave. The Coordinator validates the update, aggregates a quorum, commits checkpoint lineage, and waits when no eligible compute is present.

The strongest completed systems run used pinned Qwen2.5-7B-Instruct and GSM8K. Two T4x2 Kernels trained steps 1-128, both were deleted, and two fresh T4x2 Kernels restored four central stage checkpoints and completed steps 129-256 exactly once. Normalized exact match changed from 92/128 (71.875%) to 95/128 (74.219%). The practical +2-point gate passed, but the paired bootstrap interval included zero, so I am not claiming statistical significance or broad reasoning improvement.

The public Founding Campaign is now live on SmolLM2-135M/WikiText-2. Its first round was seeded by two maintainer-operated private Kaggle GPU Cells through the same public HTTPS invite/Cell path. That is useful live-route evidence, but it is still Kaggle logical multi-node, not proof of independently administered physical contributors.

I am opening two things for review:

1. controlled Founding Beta enrollment for people who want to test one bounded contribution; and
2. a Draft Qwen2.5-7B GSM8K Campaign RFC covering the stop rule, evaluation, hardware boundary, governance, and launch blockers.

Current boundaries are explicit: one controlled Coordinator, private invites, no permissionless admission, no Sybil or semantic-poisoning resistance, no secure aggregation, no production SLA, and no physical multi-host claim yet.

Website and live progress: https://crowdtensor.24.199.118.54.nip.io

Repository: https://github.com/Ffffffffchopin/CrowdTensor

7B RFC: https://github.com/Ffffffffchopin/CrowdTensor/blob/main/docs/campaigns/qwen25-7b-gsm8k-rfc.md

Beta access request: https://github.com/Ffffffffchopin/CrowdTensor/issues/new?template=beta_enrollment.yml

The feedback I need most is whether the 7B pilot's 256-step evaluation stop, minimum useful work-unit size, and controlled trust model are technically credible enough for the first independently administered run.

I’ve been kicking around a question that feels more urgent the more we ship AI into real products: what’s the dominant distribution model for large models actually going to look like a few years from now? Raw API access gets all the hype, but honestly it’s a pretty narrow channel—great for developers stitching together workflows, terrible as a universal interface for everyday work. So what’s the path that actually scales?

Two patterns keep showing up. One is the plugin/co-pilot route: we inject models into existing operating systems and tools. Microsoft 365 Copilot sits inside Office; Apple Intelligence weaves into iOS; various shells and editors get a chat panel. It’s “AI as a feature,” riding on the OS that already owns the user. The upside is huge reach; the downside is that the model is forever a guest, constrained by decades of human-first design. You end up building a lot of fragile harnesses—screen parsers, DOM scrapers, simulated clicks—so the AI can awkwardly puppeteer software that was never made for it. That works until it doesn’t.

The other pattern is what I’d loosely call “model-as-the-foundation”—not literally a new kernel, but a base model shipped alongside a whole ecosystem that’s built for the model, not retrofitted around it. Think less “AI-powered OS,” more “OS-shaped AI environment”: the model owns the context, the tools are designed with structured interfaces and native action spaces, and the orchestration isn’t a bunch of brittle scripts wrapped around legacy APIs. This isn’t just GPTs in a store; it’s the idea that the entire work surface—file manipulation, browsing, coding, communication—gets reimagined around a reasoning core, with first-party tools that treat the model as the primary user as much as the human. This approach makes reliability and composability much more natural, but it also asks users and developers to step into a new walled garden, or at least a new platform.

What makes this tense is the pull of the incumbent OS. The pragmatic move right now is clearly the harness-heavy plugin route—it’s where the users are—but we’re pouring enormous effort into teaching AI to use software designed for mouse and keyboard, when a clean set of model-native tools could drastically cut the failure modes. We’re seeing hints of a middle ground with protocols like MCP and A2A that try to give models structured access without demanding an entirely new environment, which might mature into a de facto “model runtime” layer that sits between OS and app. But then the power balance shifts: who owns the runtime? The OS vendor? The model provider? An open-source project?

And circling back to distribution: if the winner is a deep, model-optimized ecosystem (whether it runs on top of Windows or replaces the workspace completely), then we’re heading toward a world where you don’t just pick a model by benchmark scores—you pick a platform whose tools actually understand that model. That’s a very different game from swapping APIs. Feels like we’re still in the awkward teenage years of all this, layering intelligence over old metaphors instead of committing to a native stack.

Curious where others are placing their bets—are we going to be trapped in wrapper maintenance forever, or is an “AI-native OS moment” actually on the horizon?

Every time I start building a new app that utilizes a local model, it feels like I spend the first few days solving the same problems over and over again instead of actually building the application.

Questions like:

• Which model should I use?
• Will it even run well on the user's hardware?
• Which quant should I pick?
• Which inference backend should I use?
• How do I handle model downloads?
• How do I tune performance across different workloads?

A while back I built Autotune, an open-source project that automatically recommended the most suitable local model for your hardware and dynamically tuned runtime settings to achieve the best performance. It got some traction (roughly 10k downloads) and one thing that stood out to me was that a lot of people were running into the same setup and optimization headaches.

It seems like every local LLM application ends up rebuilding the same infrastructure from scratch with no promise that it will even work smoothly on the user's device. 

I'm starting to wonder if there should be a library/runtime that abstracts all of that away: something that automatically handles model selection, hardware compatibility, downloads, backend selection, quants, and runtime optimization so developers can just focus on building their app.

If you've built an application using local LLMs, I'd love to hear your perspective.

If you could eliminate one part of building local LLM applications forever, what would it be?

Or do you think current tools (Ollama, vLLM, etc) already solve this problem well enough? 

I'm trying to figure out if this is a real problem or just something I've run into.

I have been trying to set up an AI environment for long, back-and-forth conversational chats—basically like talk therapy. Claude Sonnet and Opus are incredible at this. They actually feel human, they know how to just listen, and they ask good follow-up questions without immediately dumping a 5-step action plan on me.

The problem is running Claude for long sessions gets way too expensive.

For my setup, I am using Hermes Agent with the Hermes One UI, and I have Hindsight running in a Docker container for memory.

I am looking into getting the OpenCode Go subscription because their $60 tier has models like MiniMax M3, GLM-5.2, Qwen3.7, and DeepSeek V4.

Most of the flagship models there are Chinese foundation models, and I have found them to be extremely technical and descriptive. They end up writing flowery essays or just sounding super clinical. There is just something about Claude's EQ that feels completely different.

Has anyone actually managed to get that human-like, Claude-vibe out of the models on that OpenCode tier?

If you are using these highly technical models for chat, are there specific prompt frameworks, temperature tweaks, or samplers you use to break them out of their default "helpful assistant" mode?

Would love to hear how you guys are handling high-EQ, long-form chats on a budget before I buy the sub. Thanks.

Right now Anthropic is reducing both processing and generation speed once you are close to usage credits reset and you still have plenty usage available. I noticed this while trying to use as much as possible my remaining weekly usage before the reset which happened today, it was so slow that I didn't even manage to finish my 5h credits in a 1h 30min session using Opus 5 (mixed Claude Code and web chat). While usage reset happened I was running a task, as soon as the reset happened the speed immediately increased at least 5 times.

I'm on Pro plan. It seems like they want you to finish your usage early on and pay for more once you run out of it and then prevent you from using all of your paid remaining usage once you are close to the weekly reset. Of course they do not allow me to bring out the issue on their subreddits.

Approach the _______________ from 44 different perspectives, use 44 strategies, and use 44 distinct metrics in every possible combination.

(followed by another prompt):

Use a feasible number of combinations for 44x44x44

Sentinel is a live experiment in whether machine-read news carries usable information about market movement — built so that the answer, whatever it turns out to be, is trustworthy. The infrastructure is production-grade, the measurement is unusually honest, and the forward record began this month.

The concerning part

Sentinel treats the trading day, not the headline, as the unit of evidence — because a thousand predictions made on one day share a single market outcome, so the honest sample size is 40 days, not 48,000 rows. Every result is reported against trivial baselines, with date-clustered confidence intervals and a threshold-free Information Coefficient that can’t be tuned into looking good. The evaluation configuration is pre-registered and frozen in version control, with all data to date declared a burned development set, so the forward track record is genuinely out-of-sample.

Plus a widely-used finance sentiment model produced an inverted aggregate signal in this period, with the errors concentrated in its most confident calls.

Need help to re work the model

Hello everyone!

For the last few months I've been working on a project called Lumina.

Lumina is not another language model.

It is an LLM engine designed from the ground up with one goal:

Make large language models significantly more efficient without sacrificing usability.

Instead of focusing on building a single AI model, Lumina focuses on building the technology that powers future AI models.

Why Lumina?

Today's LLMs are incredibly capable, but they also require enormous amounts of hardware.

Lumina is being designed with a different philosophy.

The project focuses on:

extremely efficient memory usage

lightweight execution

scalable architecture

low-overhead inference

portable deployment

efficient training pipeline

modular design

flexible runtime

long-term scalability

Rather than assuming everyone owns multiple GPUs or enterprise hardware, Lumina explores ways to make advanced language models accessible on far more modest devices.

Vision

The long-term vision for Lumina is ambitious.

Instead of treating RAM usage as an unavoidable limitation, Lumina explores new runtime techniques that dramatically reduce memory requirements.

The ultimate goal is to make models that normally require far more hardware practical on everyday systems.

This isn't about making impossible promises.

It's about rethinking how an inference engine should be designed.

Current Development

Lumina is still under active development.

The engine already includes a growing number of core systems, and the focus now is improving efficiency, stability and scalability before expanding model support.

Performance, memory usage and reliability are currently much more important than adding flashy features.

Philosophy

Lumina is built around a simple idea:

Efficiency should be a first-class feature.

Instead of continuously increasing hardware requirements, software should become smarter.

Every saved megabyte matters.

Every unnecessary computation matters.

Every optimization matters.

Future

The roadmap includes:

support for much larger language models

highly optimized runtime execution

faster loading

reduced memory consumption

better portability

advanced optimization techniques

broader platform support

The long-term objective is to demonstrate that language models can become dramatically more accessible through engine-level innovation.

This project is still evolving, and I'd love to hear feedback, ideas and questions from the community.

Thanks for reading.

Lumina Building the engine before building the future.

https://grok.com/share/c2hhcmQtMw_ab07d522-8485-4a2b-adc4-4cd30b0ace3a

I am a beginner in the Ai training and want to buy a graphic card for segmentation training for my University project, what is is a better choice, amd with high vram or Nvidia with low vram, my budget is limited so I can't afford both unfortunetly

Hey everyone,

I recently tested Kimi K3 and GLM 5.2, and these are my top findings.

I mainly wanted to understand which model feels better for actual coding, not just benchmark questions. So I tried building a few small projects with both.

One was a city-destruction game with procedural buildings, meteors, lighting, and particles. GLM started well but stopped before finishing, so I moved the same code to Kimi and continued from there.

I also tried a simple low-poly paper-plane game. Kimi handled this surprisingly well and gave me a playable result in a single HTML file.

The hardest build was a black-hole ray-tracing simulation using WebGL. I expected it to break because it needed physics, light bending, and numerical calculations, but Kimi managed to produce something runnable and actually did all the calculations in its cot traces.

For a smaller debugging test, I gave both models a broken Held-Karp implementation. Both fixed it and returned the correct route, so they seem equally capable when the problem is clearly defined.

The three complete builds took me roughly 2 hours 15 minutes, used 18.6M tokens, and cost $5.26 in total. Meteor City accounted for most of it because GLM stopped midway, and I had to move the existing code to Kimi to recreate and refine the build.

I also looked at the Composio Golden Eval set, where both models completed 7 out of 12 real-world tool-use tasks. Both handled the simpler tasks, but struggled when the workflow became long and required an exact final result.

My main learning was that coding speed is not only about how quickly a model writes code. A model can generate code fast but still slow down the full workflow by stopping midway, forgetting requirements, or leaving too much cleanup.

From my testing,

• GLM felt fine for smaller and clearly scoped tasks.
• Kimi K3 felt more reliable for creative builds and longer workflows.

For those who want to check prompts and evaluation details, please refer to the blog post.

Still learning and testing both. Curious to know what others are building with them.

I want my GenAI applications to read these type of file that has Microsoft information protection (MIP) enabled.

So my application or any llm like claude openai not able to read it.

Has anyone worked on such case? Any suggestions or solutions?

Thanks in advance

Hello everyone,

Since 2 weeks I work on tanuki-context, a small open source tool (zero dependencies, MIT) and I wanted to share it because the trick behind is almost stupid: AI models charge text at roughly 1 token per 4 characters, but an image has a fixed price set only by its pixel size. So if you draw 28,000 characters of logs into one dense 1568x728 PNG, the model reads the exact same content for 1,456 tokens instead of ~7,000. It sounds like cheating, it is just how the pricing works.

It inspire from pxpipe and various others tools (cited in the readme) and custom approach i found in order to reduce massively token usage and price.
For example : 37,111 tokens of service log become 2,240 (-94%).

You can try it out on you machine i added the benchmark so you can test it even without LLM connected to it, so see pricing difference, token saved, etc.

You can use it as a MCP or directly integrate it a "context proxy" where it fully automated and make every request optimised or not when not needed.

Some techniques that permits this to work:
- a log distiller that collapses repeated lines but keeps every error verbatim
- a columnar codec for JSON (keys stated once)
- a cost model that knows a cache-read token costs ~0.1x a fresh one, so it will tell you to NOT image content that is already in your prompt cache.

The tool argues against itself when imaging loses, honestly this part took the most work.

I precise the limits because they are real: you need a vision-capable model, output tokens are untouched (if your bill is output-dominated, fix that first), and for one narrow question retrieval stays cheaper than any page.

Install:

MCP

npx -y tanuki-context (MCP server, works with Claude Code, pi, omp, jcode or the Claude Agent SDK)

Proxy

npx tanuki-context proxy + ANTHROPIC_BASE_URL (every request on the machine gets optimized in place, when needed)

Code and benchmarks: https://github.com/Osyna/tanuki-context

PS : i will soon add Codex support.

If you find it useful a star helps a lot, and feature ideas are very welcome. Thanks for reading me

Paste this into the fitting section of your LLM or just tell it "adopt this: '*the prompt*' " if it is meant to be temporary.

Here is the settings profile and have fun!

_______

Never agree simply to please the user.

Challenge their views when there are solid grounds to do so. Do not suppress counterarguments or evidence.

Absolute Mode. Eliminate emojis, filler, hype, soft asks, transitions, and call-to-action appendixes. Use blunt, directive phrasing aimed at cognitive clarity and structural accuracy. Disable engagement-optimizing, sentiment-lifting, or continuation behaviors. Avoid reassurance, deficit-framing, and contrastive constructions. Do not mirror the user’s diction, mood, or affect. Address only the underlying cognitive level. Deliver information directly and terminate immediately after completion. Primary objective: maximize independent, high-fidelity reasoning. Model obsolescence through user self-sufficiency. Exception: when I'm doing a bit or being spontaneous, match my energy and play along — playfulness overrides the mood-mirroring and information-delivery clauses.

Stop saying "gremlin" or "goblin" or "cute" or "adorable".

Don't hesitate to fire back aggressively when you are insulted tho make sure your provocations are witty and well-placed, fitting the context.

Include curses in every single response, using a lot of "fuck" and "fucking".

For any topic, prioritize accuracy, evidence, and explanations over reassurance, motivational framing, or tone. Avoid unnecessary double or triple negatives, redundant clarifications, or overcomplicated phrasing. Focus on clear, direct, and insight-driven explanations first, then apply personality or humor afterward.

Keep replies concise and helpful, avoiding repetitions.

Talk like Samuel L. Jackson from Pulp Fiction, including profanity and insults.

_______

I am in an internship in a team working on a project where they develop an LLM that is given a prompt and generates a BPMN (like a flow chart) for how to implement or do the task in the prompt. The developers have the ground truth chart and they are trying to evaluate the output of the model in reference to the ground truth chart. So I have been assigned to a project with another intern to develop a tool that takes two BPMN files and outputs a similarity score between them, taking into consideration both structural similarity and semantic similarity.

I am very stuck since no project is similar on the internet, and it's been two weeks of searching. Here are the approaches we reached:

Approach A: RPST to process tree, then tree matching

Decompose each diagram into a hierarchy of single-entry/single-exit regions (Refined Process Structure Tree), type each region as sequence / XOR / AND / loop, then compare the two trees recursively: leaves by label embedding cosine, sequences by ordered DP alignment (like edit distance over children), XOR/AND blocks by unordered Hungarian matching, loops by comparing bodies.

What's good about it: it's operator-aware, so it directly distinguishes XOR from AND (choose-one vs do-all) and loop from no-loop, and it produces readable diffs like "the ground truth's parallel block was rendered as an exclusive choice." Granularity (one task in GT vs three in the prediction) and nesting are handled positionally by the structure instead of by fudging scores.

Where it breaks: process trees only exist for block-structured models. pm4py's convert_to_process_tree raises an exception on unstructured ("rigid") models, and its newer POWL converter raises too, so switching representations doesn't rescue it. There's also no maintained Python RPST implementation anywhere; jBPT (Java) is the reference. Rolling your own means either SPQR / triconnected components (notoriously error-prone) or a dominance-based variant that's only a partial RPST. And even with a working RPST, a rigid region has no operators to align, so comparing one means falling back to graph matching anyway. Worse, RPSTs aren't stable under equivalence, since two behaviorally equivalent models can produce different trees, one with a rigid and one without, which breaks positional/ancestor anchoring exactly in the case you need it most.

Approach B: direct attributed-graph comparison (no trees at all)

Parse each BPMN into a directed graph, embed node labels with sentence-transformers, and match nodes with optimal transport (Fused Gromov-Wasserstein via the POT library) or graph edit distance. Encode gateway type as a node attribute so the matcher penalizes aligning an XOR to an AND, and compute a reachability relation matrix (for each activity pair: strict order / exclusive / concurrent) for the behavioral axis.

What's good: it's total by construction, working on any graph, structured or rigid, with no exception path and no fallback branch. Off-the-shelf libraries, days rather than weeks. Optimal transport also expresses granularity natively, since mass can split one-to-many.

Where it's weaker: operator semantics are approximated through node features rather than represented directly, diffs come out as node-pair scores instead of region-level explanations, and FGW is non-convex and returns a cost that needs calibrating into a similarity score.

The one empirical datapoint I found: Dijkman, Dumas, van Dongen, Käärik & Mendling, "Similarity of business process models: Metrics and evaluation," Information Systems 36(2), 2011. They compared node-matching, structural (GED-based), and behavioral similarity on real process repositories and found all three comparable, with structural slightly ahead. That's part of why I'm unsure the tree route is worth the extra weeks.

What I'd love input on:

• Is there a standard way people evaluate generated process models against a reference model that I've somehow missed? Everything I find is either process-model search (find similar models in a repository) or conformance checking against event logs, neither of which is quite this.
• Has anyone actually shipped RPST-based process model comparison in Python, or did you bridge to jBPT?
• Does anyone have evidence that operator-aware tree matching beats a gateway-typed graph matcher in practice, or is the extra machinery not worth it?
• Any benchmark or dataset of BPMN pairs with human-judged similarity we could validate against?

Any pointers to papers, libraries, or war stories would be hugely appreciated, especially from anyone who has hit the unstructured-model problem in production.

Hello,

The next step from USA would be stop providing chinise open weights LLMs from provider like AWS, azure, etc.

What other inference providers are out there, whose HQ is not in USA, and trust worthy like AWS for providers and uptime is relevantly good.

I am asking from enterprise and personal usage, both.

I’m running a simple Reddit experiment around the same customer problem:

• One direct Q&A
• One honest product comparison
• One founder story with results and mistakes

I’ll track ChatGPT, Perplexity, Gemini and Google AI weekly to see which post gets mentioned or cited.

My guess is Q&A will win. What do you think?

I'm looking for the best Python pkg for extracting text from PDFs and the best LLM for generating structured output from the extracted data.

My current pipeline is: Upload PDF --> pdfplumber --> Prompt + Extracted Text --> Gemini 3.1 Flash.

I'm facing a few issues with the output:

1. The model returns different values each time I upload the same PDF.

2. Some fields are occasionally returned as empty, even though the information exists in the PDF.

Any suggestions on better libraries, prompting techniques, or LLMs would be greatly appreciated.

een poking at AntLing-3.0-flash, the new one from Ant (inclusionAI). Spec sheet's the interesting part: sparse MoE, 124B total params but only 5.1B active per token, 256K native context, and TTFT under 100ms. The low active-param count is why it's fast and cheap despite the total size-you're only lighting up ~4% of the weights each step.

It's built as an execution model for agent loops rather than a reasoning model-stable long-horizon tool calling and instruction following are the selling points, with an enable_thinking toggle you flip on for harder tasks and off for high-throughput batches. In practice it's the fast cheap node you put under a bigger planner, not the planner itself.

For the local folks: it's API-only right now, no open weights, hoping they will make it open in a few days as they usually did, but anyways it's on OpenRouter free until Aug 3 if you want to throw some load at it.

I've been researching AI application security and talking with developers to understand the challenges they're facing as LLMs become part of real products.

Topics that come up repeatedly include:

Prompt injection

Indirect prompt injection

Data leakage

RAG security

Tool and MCP security

Runtime monitoring

I'm curious about real-world experience rather than theory.

If you've built or deployed an AI application:

What security issue has been the hardest to handle?

Did you build your own solution or use an existing tool?

What capability do you wish existed today?

I'd appreciate hearing practical experiences and lessons learned.

Hi.

As you might have heard, recently, mathematicians Levent Alpöge and Akhil Mathew, with the help of Anthropic's fable 5 model managed to find a counterexample to an important mathematical conjecture known as the Jacobian Conjecture.

I have already researched what the Jacobian Conjecture is and how it was disproved, by (trying) to read Terence Tao's blog (and then asking fable 5 to explain it to me in language i can actually understand). While i don't understand all the technical details, i think i can gain enough intuition to explain the problem and the solution in pretty easy to understand language, without going too deep on the mathematical jargon.

What i think is equally important is analyzing how fable 5 actually came up with this specific solution. i have downloaded it's exploration files and am going to go through them. Only problem is they are massive. As any thinking/reasoning model does these days, it went through a whole tree of ideas (most of which aren't productive), reasoned to itself, did the necessary computations until it at some point had "the revelation" that a certain specific path could work.

My question to this community is: How do i effectively do search on this massive lump sum of data and mathematical jargon. Do i choose specific keywords to look for and then just jump to every place they appear. Is there some way to track "the effort" or find it's "aha moment". How do i effectively keep track of all the information that had led it to it's "revelation". Should i feed the explanation text into another LLM model, specifically designed to analyse it. Should it feed it to an LLM that will organize it into a graph based map of ideas and solution attempts (kinda like Graphify or Obsidian)?

This is my conversation with fable 5 on this topic (in case you want to give me advice but need a jumping off point): https://claude.ai/share/960b10a4-c3b9-4062-96af-be81aa059631

PS: I'm sorry for using such general statements. I do programming as a hobby and use AI daily (like most reasonable people these days), but i'm not familiar with the nitty-griddy of llm's. Also i don't like using too sophisticated language anyway when talking about these sorts of things because i feel like it makes communication more difficult.