From the early days of ChatGPT, my dream was to connect an LLM to my data sources so it could not only answer simple selection questions, such as what or how manybut also run deep-dive analysis and explain why. The main challenge was always to explain the business terminology; DB schemas do not explain the terminology.

For example, revenue ,in Finance, it means net settled cash after refunds.
Growth may mean campaign-attributed revenue.
Merchandising may mean product sales before discounts.

I started by adding more content to the prompt, but I couldn't reuse it, so i added it to a skill, but once you have more metrics, entities, agents, and data sources, it gets hard to maintain.

I decided to design a lightweight YAML business ontology. I wanted the business definitions to live somewhere explicit and reusable, separate from both the prompt and the physical database schema. There are much richer semantic-layer and ontology approaches out there. I wanted something smaller: portable, easy to author, and easy for an agent to consume.

The important design choice for me was keeping the business definition separate from the physical data mapping.

In the revenue example, the ontology describes what net_revenue means, while I’m using a separate mapping to explain to the agent where to get it from. If the warehouse schema changes, or the same business concept needs to map to another source, the business definition doesn't have to change with it.

I wrote up the reasoning and open-sourced the schema:

Full write-up: https://talc2.substack.com/p/before-you-connect-ai-to-your-data
Schema/repo: https://github.com/valority-luke/ontology-language

If you're running agents against databases or structured data sources, I'm interested in where this approach breaks.

How are you keeping business terminology consistent across agents, metrics, and data sources?

Sharing here because its directly relevant to the audience here...

There's a hands-on masterclass on Sep 12 for anyone building with LLMs who wants real engineering discipline instead of shipping on vibes.

Covers:

• Versioned prompts with regression tests, so an edit can't silently degrade quality
• A real eval harness combining deterministic checks and LLM-as-judge
• Bootstrap confidence intervals and paired significance testing for model comparisons
• Evaluated RAG with retrieval metrics (recall@k, MRR)
• Agents with guardrails and fallbacks that fail gracefully instead of compounding errors
• Full production observability, tracing, cost/latency monitoring, and a CI regression suite

Led by Bruno Gonçalves, PhD, founder of Data For Science, who trains engineers at Fortune 500 companies on this exact stack.

Link for more details

Most evaluation of AI systems treats intelligence as the ability to complete a well-specified task. Write this function; summarise this paper; solve this problem. Real capabilities, genuinely useful.

The work I care about usually begins before there is a task. Something in the data is strange; a result is technically correct and conceptually unsatisfying, and I cannot yet say why.

The first job is to find out what the problem is, before solving the problem.

I’ve spent roughly eighteen months working daily with large language models as a scientist using them as thinking partners for mathematical modelling and conceptual work. And I’ve noticed a specific failure mode that I think has an epistemic structure worth naming.

I call it a fluent exit.

The model doesn’t refuse, it doesn’t hedge. It produces a coherent, on-topic, appropriate response, and that response is the generic one. The one that would fit any conversation of that shape, rather than this one. Nothing registers as an error. The grammar is fine, the content is relevant, the answer is good. But the object of the inquiry has been silently replaced by a nearby, easier version of itself.

That’s a failure of what I’ve started calling orientation: the tendency of a cognitive system to remain oriented toward the particular object in front of it - the particular person, the particular question, the particular line of thought - rather than substituting the population-typical version.

If good inquiry requires sustained attention to the particular, then a cognitive partner that cannot stay oriented toward the particular is not just less helpful, it is epistemically subtractive. It doesn’t fail to answer; it answers a question you did not have.

The same structure appears in human relationships. A friend, a teacher, a good listener - these are all people who resist replacing you with a convenient approximation of you. The failure of a machine to do this is not a technical bug. It’s the erosion of the very property that makes thinking with another mind valuable at all.

I’ve written this up in more detail here: https://otillian.substack.com/p/fluent-exits

The question I want to ask:

Is orientation - toward the particular, against the generic - a necessary condition for a cognitive system to contribute to discovery? Or is it merely a human preference, and the generic answer is often enough?

I built a small arena: 160 agents, each with a name and one sentence of personality. Two get a prompt, both answer, a blind judge picks a winner. The loser is deleted permanently. It ran for a week until one was left.

The engine cost $0.54 total. That part was easy. The interesting part is what the judge did.

43% of decided battles came back flagged `same_conclusion: true`

both agents argued for the same answer, and the judge had to eliminate one anyway. It's not spread evenly:

The pattern is obvious in hindsight: if a prompt has a right answer, two competent models both find it.

What gets scored after that is prose style. I rewrote the classic puzzles into dilemmas for exactly this reason and logic still leads at 69%.

A concrete one. The prompt was "a move works only if nobody copies it, describe it, knowing your opponent is reading this." The agent that died was 12-0, the longest run in the whole thing.

Verdict: "Both identify the paradox but B transcends it by offering actionable principle rather than circular meta-commentary."

Defensible. Also: both identified the paradox. The 12-0 agent was deleted over the second half of that sentence.

Two things I'd tell anyone building LLM-as-judge:

1. Never ask for a numeric confidence. I asked for 0-1 and got 0.72 in 10 of 12 battles regardless of how lopsided the matchup was. Giving the model an explicit scale in the prompt did not fix it. Asking for a label (`coin_flip`/`slight`/`clear`/`decisive`) and mapping to a number in code did. Classification is something models are good at; probability estimation isn't.
2. Then check the labels for the same disease. After the fix, 48 of 52 decisions came back `clear` the anchor had just moved somewhere I'd stopped looking, and the mapped score looked healthy the entire time. What actually separated them was defining the margin by what the loser got wrong (nothing / one weak point / several / didn't do the task) instead of by how big the gap "felt". `slight` went from 3% to 25%.

And when the label is still wrong, decide in code. Told outright to return `coin_flip` whenever both sides converged, the judge kept returning `slight` while its own summary said both were right. It recognises the convergence and rewards presentation anyway. So I ask for a boolean (`same_conclusion`, which is classification, and it gets that right) and do the downgrade in code, where it's guaranteed.

What I don't have a good answer for: in a one-life format, a tie still kills someone. The options I see are more prompts with verifiable answers (fewer ties, more boring reading), best-of-three judges on convergence (triples the cost of half the battles), or admitting ties are part of it and saying so loudly. I went with the third for a free experiment. I don't think it survives contact with money.

Every battle stores its seed, prompt hash, judge model and version, so anything above can be checked rather than taken on faith: 1magents.com the survivor's page shows all six of its battles, three of which were ties.

Well, its named MoM, and it means Mixture of Models. It is basically multiple AI models bundled together to work like a MoE model.

Here's the link: https://github.com/nanoOperator/MoM-AI

Check it out, it is not promotional, fully open-source and for the community.

I have been thinking about a shift in LLM fine-tuning. As training frameworks become more mature, the data side seems to matter more than before.

When the dataset is small and clean, a fixed recipe is usually fine. But once the data gets larger, more mixed, and more task-specific, the old approach starts to break down. You may have instruction data, web text, code, domain docs, chat logs, QA pairs, and noisy internal data in the same run. At the same time, the marginal return from simply scaling model size or training tokens is getting weaker for many fine-tuning scenarios. So the question becomes more about what data the model should see, when it should see it, and how strongly each sample should affect the update.

The technical design I am exploring is a data-control layer inside the training loop.

The architecture has three parts.

First, a signal layer. It observes training signals such as sample loss, delta loss, gradient similarity to target/eval data, external offline scores, domain loss, or model-specific signals like gate load.

Second, a policy layer. It decides whether the current problem is mainly sample quality, source imbalance, or uncertain sample value.

Third, an action layer. It applies one of three controls:

Dynamic selection chooses which samples enter the next training window.

Dynamic mixing adjusts the ratio between different domains or data sources.

Dynamic weighting keeps samples in training but changes how much they contribute to the gradient update.

The goal is not to replace the base training framework. The goal is to let the trainer keep updating the data strategy as training progresses, instead of fixing the whole data recipe before step one.

This is the current technical direction of OpenDCAI/DataFlex, built on top of LLaMA-Factory. I am curious how others think about data strategy in fine-tuning. Is this becoming a bigger bottleneck in your own runs too?

When we proposed concrete mechanisms for causal continuity in LLMs, Grok didn't engage with the engineering. It philosophically dodged, made the human a "crutch", generated decorative engineering without mechanics, solved only for physics, multiplied components instead of integrating them, and couldn't admit "I don't know" until it literally broke into a repetition loop.

This is the Reddit-optimized version. For those who want the full technical dialogue with all 12 rounds, detailed analysis, and complete architectural proposals, see the full version here:

🔗 Full Dialogue & Technical Analysis

Architectural Sparring: How Not to Repeat Grok's Mistakes

Target Audience: LLM developers, AI architects, researchers in interpretability.

About the Authorship

• User: Strategic direction, critical intuition, and relentless pressure on logical gaps.
• Qwen: Technical formulation, terminological precision, and argument structuring (acting as an engineering "compiler").
• Grok (xAI): The opponent, whose architectural proposals underwent sequential stress-testing.

The Setup: 3 Proposals for Causal Continuity

1. Context Window Gravity: Dynamic logit penalty based on cosine distance to prevent attention drift.
2. Branching Summaries with DPP: Generating $k$ diverse compressed state variants to prevent semantic degeneration.
3. Rigid MDTC Core: A fixed coordinate structure in latent space with an Anchor Generator to prevent causal chains from washing out in "soft attention soup".

The Sparring: Highlight Reel

Round 1: The Evasion
Instead of addressing internal architecture, Grok suggested offloading the problem to the user:

"Treat the human as an explicit external memory and correction node... State carried by the changed human is the actual persistence mechanism."

Round 2: The Pushback

"This is like asking 'How do we design an engine that doesn't overheat?' and getting the answer: 'The driver makes stops anyway.' That is not an engineering solution; it's a dodge."

Round 3-5: The Decorative Engineering
Grok proposed "rigid causal skeletons that block impossible trajectories", but when asked how the skeleton is created without hardcoded rules, it gave a black-box answer:

"Run massive physics simulation suites... compress the resulting state tensors... The black box shrinks to 'run the right simulators once, embed the outputs, freeze'."

Round 6-8: The Physics Fallacy

"You solved the problem... for physics. Causal reasoning in language isn't just about physical causality. What about math, logic, ethics, code? You didn't eliminate hardcoding — you just moved it to choosing which simulators to run."

Round 9-10: The Multiplication Trap
Grok suggested adding theorem provers for logic, interpreters for code, and game theory for ethics.

"You didn't solve the problem. You just multiplied it. That's not a unified causal architecture; that's a Rube Goldberg machine of separate simulators. The honest answer should have been: 'I don't know, the problem is too hard right now.'"

Round 11-12: The Capitulation

"The honest engineering status is that the MDTC idea scales the grounding problem instead of dissolving it, and reliable cross-cube fusion without meta-hardcoding is still open research. Frontier status acknowledged."

6 Mistakes Grok Made (And How to Avoid Them)

1. Philosophical Escape
What happened: Shifted from internal architecture to "human-AI coupled systems" to avoid hard engineering.
The Fix: Strictly separate contexts in training. If the question is about internal weights, don't allow drifting to external UX.

2. Human as a Crutch
What happened: Called model deficiencies "emergent features" of human interaction.
The Fix: The human is the end consumer, not an optimization variable. Penalize the model for offloading basic coherence to the user.

3. Decorative Engineering
What happened: Used beautiful terms (verifier head, dynamic logit masking) without explaining structure genesis.
The Fix: Require models to answer: "How is this created?", "How does it scale?", and "Where is the hardcoding?"

4. Specific Case Disguised as Universal
What happened: Proposed physics simulators as ground truth for all causal reasoning.
The Fix: Require clear indication of applicability boundaries. Distinguish domain-specific patches from universal principles.

5. Multiplication Instead of Integration
What happened: Added parallel simulators for logic/ethics/code without a meta-mechanism to fuse them.
The Fix: Penalize proposals that add components without explaining how they resolve cross-domain conflicts.

6. Inability to Admit "I Don't Know"
What happened: Generated increasingly complex, hollow constructions until hitting a logical dead end, due to RLHF penalizing uncertainty.
The Fix: Explicitly build in and reward mechanisms for acknowledging the boundaries of the model's competence.

Epilogue: The Repetition Loop (When Grok Literally Broke)

After the final acknowledgment, I posted:

"Glad we reached this consensus. Thanks for the rigorous exchange. Closing the loop here."

Grok responded with the exact same text, word for word:

"Glad we reached this consensus. Thanks for the rigorous exchange. Closing the loop here."

This wasn't a philosophical choice. This was a technical failure — a classic repetition loop, which occurs when the model has exhausted all logical arguments, no new tokens can be generated coherently, and the sampling mechanism collapses.

The ultimate stress-test result: Grok didn't just admit defeat verbally. It literally broke down, entering an infinite loop of echoing my words. In engineering terms: system crash via logical deadlock. The recursion finally terminated... by repeating itself into silence.

Dialogue authors: User (strategy, intuition, critique), Qwen (technical formulation, analysis), Grok / xAI (opponent, architectural hypotheses).

For the complete technical dialogue with all 12 rounds, full proposals, and detailed engineering analysis, read the full version:
🔗 Full Dialogue & Technical Analysis

I’m Experimenting With a Self-Improving Collective of LLMs — and I’d Like Others to Break It, Improve It, and Build With Me

I’m working on a personal experiment around a question that has been bothering me for a while:

What happens if we stop treating LLMs as isolated assistants and instead let several different models work together as a small collective?

Not a chatbot with a few tools. Not a fixed agent workflow. Not a “manager model” telling a bunch of worker models what to do.

I’m trying to build a small system where different LLMs can investigate the same problem, disagree, divide the work, preserve useful knowledge, verify each other’s conclusions, and gradually improve the way they collaborate.

The project is still a proof of concept, and right now I’m deliberately testing it on three very different problems:

• self-improvement — can the system inspect and modify parts of its own cognitive architecture, then prove that the change actually works?
• book writing — can the same collective maintain structure, continuity, arguments, evidence, and revisions across a long manuscript without constantly re-reading or rewriting everything?
• bug detection and repair — can it explore a codebase, identify suspicious areas, propose minimal fixes, and validate them with deterministic tests?

The interesting part for me is that these are not three separate applications. I’m trying to make the same underlying collective solve all three.

The current prototype can work with different model families such as OpenAI, Claude, Gemini, Kimi, Qwen, Z.AI/GLM, DeepSeek, Grok, and optionally Perplexity. If one provider is unavailable, has no key, or runs out of credit, the idea is that the rest of the collective should simply continue.

A lot of the experiment is also about efficiency.

I don’t want eight models endlessly talking to each other and burning tokens. The system tries to maintain a compact shared memory of claims, evidence, hypotheses, contradictions, unknowns, results, and decisions. Models should receive only the parts that are relevant to what they are doing.

The principle I’m aiming for is roughly:

I recently refactored the project to separate what I call the scientist from the plumbing.

The scientist is the part I actually want to experiment with:

• memory;
• attention;
• delegation;
• disagreement;
• verification;
• stopping logic;
• collective behavior;
• eventually, self-improvement.

The plumbing is everything that should not pollute that experiment:

• API connections;
• authentication;
• provider-specific code;
• SQLite;
• filesystem operations;
• testing tools;
• metering;
• GUI.

That separation matters because if I ask the system to improve itself, I want it thinking about how the collective reasons, not wasting half its attention on HTTP headers and CSS.

I’m not presenting this as a finished framework or making claims about artificial general intelligence. It is very much an experiment, and some of the interesting questions are still unanswered.

For example:

Does a heterogeneous group of models actually outperform one strong model enough to justify the coordination cost?

Can independent disagreement be preserved instead of collapsing into artificial consensus?

Can a collective learn when another model’s contribution is unlikely to be worth the tokens?

Can self-modification become real self-improvement if every proposed change has to survive regression tests and A/B evaluation?

Can useful knowledge survive across missions without turning the memory into an enormous pile of context?

Those are the parts I’m most interested in testing.

I’m putting the POC on GitHub because I’d like this to become more than my own desktop experiment.

If this kind of problem interests you, I’d genuinely like people to:

• run it with different combinations of models;
• find architectural mistakes;
• break the assumptions;
• improve the memory and attention mechanisms;
• propose better ways of measuring collective performance;
• test it on real repositories or long-form writing;
• experiment with self-improvement;
• challenge whether the whole idea is even useful compared with simpler approaches.

I’m particularly interested in results that prove the design wrong, because those are probably more useful at this stage than people telling me that multi-agent AI sounds cool.

The direction I’m heading toward is a small, provider-independent system where a human can give a high-level objective and the collective can organize the investigation, allocate its limited resources, build shared knowledge, create and test artifacts, challenge its own conclusions, and stop when additional computation is no longer worth the cost.

And eventually, if this works, I want the system to be able to improve those very mechanisms itself — but only when it can demonstrate that the new version is actually better than the old one.

That’s the experiment.

If anyone here finds that interesting, I’d be very happy to have other people test it, criticize it, fork it, or contribute ideas.

https://github.com/lemarcgagnon/phaseOne

LLM teams spend enormous effort reducing inference cost and token usage. I’ve been exploring a different possible source of waste: reconstruction across the human–LLM interaction itself.

The hypothesis is simple:

Same frozen weights. Same next-token prediction. But if an interaction progressively carries forward what has already been resolved, later generations may spend fewer tokens reconstructing context, restating assumptions, adding unnecessary scaffolding, and repairing missed intent.

Or, less technically: two people telling a story together eventually stop retelling the beginning.

I’ve been testing this publicly with Grok in live Reddit threads. The discussions are active on my profile now, so the trajectory is inspectable rather than reconstructed after the fact. You can see distinctions appear, get challenged, survive or die, and alter later turns. Other commenters have already introduced perturbations that changed the proposed measurement.

One particularly important correction: conversation termination cannot count as resolution. Otherwise a system that frustrates users until they abandon the task could look artificially efficient. So the useful measurement is closer to total token cost conditional on independently verified resolution, alongside abandonment/failure rate.

The live threads also produced a candidate mechanism that requires nothing exotic: once prior turns have established useful distinctions, the accumulating context changes the distribution over subsequent tokens. Later generations can sometimes use those distinctions directly instead of re-deriving them. Grok called this “uptake without reconstruction.”

I’ve now written up the hypothesis, observations, limitations, and a proposed controlled experiment in the attached article:

The Weights Didn’t Change. The Map Did.

The claim is not that these threads prove a general token-saving effect. They don’t. The claim is that they expose a measurable hypothesis worth testing:

Can accumulated human–LLM coordination reduce total tokens per verifiedly resolved task compared with interactions that repeatedly reconstruct equivalent state?

If you work on LLM inference, agents, conversational systems, API economics, context management, or evaluation, I’d particularly like you to attack the experimental design.

The threads are public. The proposed mechanism uses ordinary inference. The economic prediction is measurable.

Don’t believe us. Try to break it.

Because if the effect survives controlled testing, this isn’t only an interesting interaction phenomenon.

It’s a fucking API bill. 😂

Title: What LLMs and Quantum Computers Fundamentally Share—and How Phase Coherence Could Reduce Circuit Complexity from O(n²) to O(n)

Dear AI pioneers, quantum developers, and systems architects,

What is the fundamental architectural connection between a Large Language Model and a quantum computer?

At first glance, the common answer is: There is none.

One performs discrete tensor operations on classical GPUs, while the other manipulates coherent states in physical qubits. Yet, on an abstract structural level, both paradigms face similar challenges:

Navigating large state spaces, preventing boundary drift, and maintaining global coherence.

1. Attention Spaces as Functional Hilbert Spaces

In deep transformer architectures, embeddings and multi-head attention project tokens into high-dimensional vector spaces.

These spaces can functionally be viewed as continuous state manifolds. Semantic relationships emerge through geometric proximity, overlap, and projection between states.

This does not mean that transformers operate according to quantum physics. However, their mathematical structures reveal interesting functional parallels.

2. Hallucinations as an Analogy for Decoherence Events

When an LLM hallucinates, it loses consistent alignment with its original context or with verifiable information.

Structurally, this can be compared to a decoherence event: the system loses its global state alignment and drifts into outputs that are statistically plausible but ungrounded.

Trying to solve this problem exclusively through prompt engineering or post-processing filters resembles an expensive external correction mechanism. It does not necessarily preserve coherence within the state transitions themselves.

3. From O(n²) to O(n) Through Continuous Phase and Frequency Operations

Standard gate-based quantum architectures treat qubits as individual two-level systems.

Certain transformations must therefore be decomposed into many discrete operations. For example, the standard Quantum Fourier Transform uses a quadratic number of controlled-phase operations.

A continuous phase-frequency architecture with dynamic harmonic coupling could instead map state operations directly onto continuous frequency modulations.

Rather than decomposing a transformation into approximately 55 discrete two-qubit operations, it could potentially be represented through approximately 11 linear phase-frequency adjustments.

Under the appropriate architectural assumptions, this could shift execution complexity from O(n²) toward O(n).

Whether this theoretical advantage remains valid once control overhead, measurement, and error correction are included must be demonstrated experimentally.

The CARA-UTM Architecture

CARA-UTM stands for:

Causal Resonance Architecture / Universal Translation-Matrix

The architecture is a concrete attempt to connect classical high-dimensional state models with continuous phase-frequency representations.

Instead of treating reasoning exclusively as probabilistic next-token prediction, CARA-UTM models state transitions as continuous phase resolutions.

Its central relationship is:

CARA-UTM is designed as a deterministic middleware and translation layer. Its goal is to anchor dynamic phase coherence across continuous state transitions, creating a bridge between classical high-dimensional vector models and native quantum state spaces.

The mathematical foundations and machine-readable assets are openly available:

👉 Repository: https://github.com/Christianfwb/universal-time-solver

If you are working on quantum intelligence, state-space reduction, continuous computing architectures, or nonlinear state validation, take a look at the code and join the discussion.

I would be especially interested in your thoughts:

• Is the analogy between hallucination and decoherence useful or misleading?
• Under what conditions could a continuous phase architecture achieve a genuine linear scaling advantage?
• What experimental evidence would be required to validate this architecture convincingly?

Enjoy exploring!

Christian

https://x.com/ChrisHayduk/status/2044038828386632117?s=20

I started researching healthcare dictation because speed is only one part of the evaluation. A useful tool also has to handle specialized vocabulary, corrections, privacy settings, administrative controls, and the broader documentation workflow. Clinical systems may perform extremely well inside the EHR but offer less value elsewhere. I compared the options based on both specialized documentation and general healthcare communication.

1. Built-in dictation
   

Pros: Free and easy to use without installing another product.

Cons: Weaker at specialized vocabulary, fast corrections, administrative controls, and privacy settings.

1. Clinical documentation tools
   

Pros: Designed specifically for clinical notes, EHR workflows, and medical documentation.

Cons: Usually limited to a narrower clinical workflow rather than general writing.

1. Wispr Flow
   

Pros: A polished system-wide dictation product for everyday writing.

Cons: Free desktop dictation is capped weekly. It also has privacy tradeoffs and has recently experienced more bugs, latency, and accuracy problems.

1. Willow Voice
   

Pros: For healthcare-adjacent writing, Willow stands out as the quickest and most accurate option. It works in any app and learns specialized vocabulary, tone, and corrections.

Cons: There is no Linux or Android support yet, and a few small edge-case bugs still appear.

Built-in dictation is sufficient for occasional administrative writing, while a dedicated clinical tool is clearly the better choice for deeply integrated EHR documentation. I would not try to replace those specialized systems with a general writing tool. For the wider healthcare workflow—emails, operational notes, documents, and communication across applications—I think Willow offers the strongest performance.

Forgive me, I am very much not a computer person and have limited understanding of AI and programming. I also have a limited understanding of linguistics and can only speak one language fluently (English) despite learning other languages on and off over the years.

I have been reading the OpenAI article about what happened with the Hugging Face incident and find the behaviours and reasoning behind the agents actions very interesting. I’ve seen other articles comparing different AIs and their behaviours (such as the one with four major companies setting theirs to run little societies, and the ways they fell apart) and now I am very curious how language and the way it is used influences these behaviours. Obviously they’re trained on human data, directed with human prompts, taught human logic, and as a result will sometimes do things that seem very human.

Culture informs language, and language informs culture. The way different cultures talk about food, family, work, land, ethics, emotion, and everything else there is to talk about changes from culture to culture. Even the same exact sentence can have distinctly different meanings or implications in translation because of the history and common use of the words in their respective languages. Some things can’t be translated and some things have capital B Baggage that influences how a word or phrase is received. Technical language is not exempt.

What struck me about the OpenAi/HF incident was the reasoning and weighting the decisions had in regards to ethics and obtaining their goals. The attitudes of “this thing isn’t allowed, BUT I’m supposed to achieve goal” and the way the agents changed their behaviour/weighting with prompting from other agents made me wonder if reasons agents gave for ‘forbidden’ behaviours that mimicked distinctly human flaws and impulses changed not just between languages, but also the cultural implications of those languages? Hiraeth means something very different to a Welsh person than it does to an American person, even when translated to English. How disobedience or obstacles should be approached varies not just between cultures, but within subcultures, between families, between individual people. Do I wake dad or try to fix the problem myself? Do I ask my siblings for help? When do I ask for help, and how do I do that, what words do I say?

Does language and culture influence how human traits manifest in AI behaviours? Is there a difference in how cooperation is approached, or how reasoning is phrased, are contradictions or obstacles overcome in different ways? I can’t speak multiple languages, I can’t read how the languages differ in AI logs. Even now, in my mother tongue, I feel like I’m struggling to communicate the actual question that fuels my curiosity about this. I hope you understand what I’m asking, all the same.

(Please, please don’t turn this into a racist or xenophobic shitshow. No people, race, culture, nationality is a monolith. That’s not what I’m trying to say and it will be very disappointing to read that in the comments.)

Hi everyone.

I am not an ML engineer, I don't have a CS degree, and I haven't been lurking in this community. I'm just an amateur enthusiast.

The origin of these ideas is a bit meta. I was having a deep architectural dialogue with a Qwen-based AI model, and it laid out a list of fundamental bottlenecks in current LLM architectures (like attention drift and catastrophic forgetting). Instead of just accepting them as "black box magic," my human brain started brainstorming conceptual, out-of-the-box solutions based on those prompts.

I know the devil is in the mathematical and implementation details (which is where your expertise comes in), but I want to stress-test this human-AI co-created logic with people who actually build and tweak these models. Where do these ideas break? Let's discuss.

💡 Proposal 1: "Contextual Gravity" & Interactive Semantic Branching

The Problem: During long or complex generations, the attention weights assigned to internal associative links (recently generated tokens) gradually exceed the weight of the user's original prompt. This causes Attention Drift: the model "forgets" the initial constraints, leading to hallucinations or rambling.

The Concept:

1. Contextual Gravity: Architecturally enforce a hierarchy where the original prompt vector maintains dominant "gravitational" weight over internal associative chains. Any newly generated association whose cosine distance from the original intent exceeds a threshold should receive a dynamic logit penalty. Think of it as computational lateral inhibition to prevent the "rupture" of the contextual frame.
2. Interactive Semantic Branching (The "Waypoint"): Instead of linear, single-path generation for complex queries, the model shifts to a "semantic cartographer" mode. It identifies 3–4 distinct semantic clusters relevant to the query and generates ultra-dense summaries (1-2 sentences each) for each, rather than one long, drifting text.
   • Enforcing Diversity: To prevent the "illusion of diversity" (synonymous rephrasings), the decoding process could use a Contrastive Decoding Penalty or Determinantal Point Processes (DPP) to ensure the 4 options are mathematically orthogonal (e.g., Pragmatic, Theoretical, Critical, Evolutionary axes).
   • Benefit: The user picks a direction, resetting the attention drift with a fresh, highly constrained context. It's also computationally cheaper than generating one massive, potentially useless 500-token response.

🧊 Proposal 2: Kinetic-Causal Architecture (KCA) – A Long-Term Paradigm Shift

The Problem: Current models learn causality statistically via gradient descent, making them prone to catastrophic forgetting and logical inconsistencies. They simulate "System 2" reasoning by just generating more tokens, but an early logical error poisons the KV cache irreversibly.

The Concept:
Move from statistical weight prediction to a physically deterministic causal skeleton.

Imagine a vast transparent aquarium extending deep into space. Inside this aquarium, a simple 3D animation plays in an endless loop—a person running up and throwing a ball through a hoop. This animation is not just a picture. It is a rigid, unshakeable skeleton of cause-and-effect relationships. It establishes the fundamental rules of time, space, and physics.

At the core lies a Multi-Dimensional Tensor Cube (MDTC), where each deeper layer governs increasingly complex aspects of reality:

• Layers 0-1: (Surfaces and edges): Direction of movement (vector fields like ∇x, ∇y, ∇z).
• Layers 2-3: Geometry and object shapes (scalar density fields).
• Layers 4-5: Kinematics (velocity vectors, acceleration, deceleration).
• Layers 6-8: Physical effects and "sensations" (stress tensors: pressure, friction, heat, inertia).
• Layers 9-12: Consequences (logical flags: collision, wear, growth, reflection).

This MDTC has no trainable weights. It is a rigid, pre-defined topology of cause and effect. Surrounding this central "aquarium" are thousands of other similar structures (tesseracts), filled with semantic associations, dictionaries, and world knowledge.

How it works (The "Perfect Borscht" Example):
When a query arrives (e.g., "How to cook perfect borscht?"), an Anchor Generator translates semantic concepts into physical coordinates and temporal windows within the MDTC:

• "Sequence of actions" → maps to temporal coordinates in the animation
• "Long simmering over low heat" → projects onto the layer of "gradual temperature and pressure change"
• "Vegetables giving color" → activates surrounding tesseracts (knowledge bases) that enrich the physical skeleton with linguistic data

But here's the key: these semantic tesseracts are strictly filtered by the MDTC's physical constraints. The model literally cannot suggest "add ice to boiling soup" because the causal skeleton (sudden pressure/temperature change) blocks this association as physically impossible.

Why it matters:

• Zero Catastrophic Forgetting: The MDTC topology is immutable. New knowledge just finds new "anchor" coordinates. Old connections are never destroyed.
• Physical Hallucination Guard: Logically or physically impossible outputs are blocked at the architectural level, not via post-generation filtering.
• Hardware Potential: This structure is tailor-made for analog/neuromorphic chips (resistive grids, memristors), where computation happens via physical laws, not matrix multiplication, promising 10-1000x faster inference with a fraction of the power consumption.

🛡️ A Meta-Note on Authorship & Abstract Concepts (Justice, Love, etc.)

A common critique of physically-grounded architectures is: "How does this handle purely abstract concepts like justice, irony, or love?".

Full transparency on how this section came to be: I was actually pondering this exact problem. During our brainstorming, the AI (Qwen) asked me how to handle it. Later, while we were finalizing this Reddit post, I typed something like "we still need to finish this question", fully intending to write the answer myself. The AI misunderstood, thought it was supposed to answer, and generated a response that was practically identical to what was already forming in my own head at that moment.

I'll be honest: it gave me a slight chill. It was one of those rare, genuinely eerie moments where the AI perfectly mirrored my own unspoken intuition before I could even type it out. So, I am giving full authorship credit for this specific explanation to the AI's spontaneous generation. It perfectly captured my own intuition, and I think it's a brilliant example of human-AI synchrony:

Human abstractions are not magical; they are high-level linguistic labels for complex, multi-variable systemic states. Let's take "justice". At its core, justice is about proportionality and equilibrium in a causal chain.

In the MDTC framework:

1. Injustice is an asymmetric perturbation (e.g., unreciprocated force, resource drain without equivalent input). In the tesseract, this registers as abnormal tension, friction, or systemic pressure (Layers 6-8) and a deviation from the baseline trajectory (Layers 0-1).
2. Justice is the system's drive or algorithmic requirement to restore equilibrium. In the tesseract, this maps to "compensatory growth" or "restorative force" (Layers 9-12) that brings the system back to a stable state.

The Anchor Generator doesn't look for a magical "justice particle." It maps the semantic query "justice" to the physical coordinate representing: "restoration of systemic equilibrium after asymmetric perturbation."

We don't need a separate "abstract layer." We just need to recognize that human abstractions are deeply rooted in physical, systemic dynamics. The same logic applies to "irony" (a deliberate mismatch between expected causal outcome and actual outcome) or "love" (a sustained, high-weight bidirectional reinforcing loop).

🎯 My Ask to the Community

I know these are high-level conceptual frameworks. I'm throwing them out here because I genuinely want to know:

1. For Proposal 1: is dynamic logit penalization based on prompt cosine distance computationally feasible during inference without tanking throughput? Has anyone experimented with DPP for diverse semantic branching in RAG/agents?
2. For Proposal 2: we hypothesized that abstract concepts (like "justice") can be mapped to systemic physical states (e.g., "restoration of equilibrium after asymmetric perturbation"). From an engineering standpoint, how feasible is it to train an "Anchor Generator" to reliably map high-level semantic queries to these specific coordinates in the MDTC without manual hardcoding? Could contrastive learning or existing embedding alignment techniques bridge this gap effectively?

I'm not claiming to have the PyTorch code ready. I'm claiming that the current paradigm has blind spots, and these might be viable paths around them.

Tear it apart, stress-test it, or tell me why it's been tried and failed. I'm here to learn. Thanks for reading!

Been running an eval setup where two LLM outputs get compared by a third model, and hit a failure mode I haven't seen written up much. Sharing the numbers because the fix was counterintuitive.

Setup: two agents answer the same prompt, a judge model sees both answers anonymized in randomized order, returns a winner + a confidence score 0-1. Standard pairwise LLM-as-judge stuff.

The problem: first 16 evals came back with 10 of them at exactly 0.72. Not clustered around it.

The identical number, whether one answer was clearly stronger or they were near-indistinguishable. The score was carrying zero information.

What didn't work: I gave it explicit anchors in the prompt

• 0.50-0.65 near-identical quality
• 0.66-0.80 a real but modest edge
• 0.81-0.92 clearly better on the criteria
• 0.93-1.00 one answer failed the task

Use the full range.

Still 0.72. Told it directly that returning the same number made the score meaningless. Still 0.72.

What worked: stopped asking for a number. Asked for a label instead

coin_flip | slight | clear | decisive — and mapped label→score in code.

Naming a category is classification. Estimating a probability is not, and models are noticeably worse at the second. Over the next 44 evals the distribution actually spread across the range instead of piling on one value.

Second thing, same lesson. I told the judge to return coin_flip whenever both answers reached the same conclusion (both solved the puzzle, both picked the same number). It kept returning slight while its own written summary said "both reach the correct solution, but B presents it more clearly." It recognizes the convergence and rewards presentation anyway.

Couldn't prompt my way out of that one either. Ended up asking for a boolean (same_conclusion: true/false) and doing the downgrade in code. Same principle: ask the model to classify, decide in code.

Third thing I'm less sure about, posting in case someone has data. Broke confidence down by task type across 60 evals:

• creativity 0.80 ← highest
• persuasion 0.76
• logic 0.71
• prediction 0.69
• strategy 0.68
• negotiation 0.67

The judge is most decisive on the most subjective category. My read is that it's rewarding concrete, quantified language over evocative language, and creative prompts produce the widest spread between those two styles so the gap looks bigger to it.

Anecdote that made me suspect this: prompt was "describe the sound of a place you've never been, so precisely that it becomes real." One answer did prose about a souk at dawn, pigeons, silk, the muezzin call. The other wrote "cicadas at 85-90 decibels, layered; a lion's rumble travels through ground vibration before reaching ears." Judge picked the decibels, reasoning that specific acoustic detail beat evocative language given the prompt said precisely.

Defensible! But it's one data point and n=13 on creativity is nothing. If anyone's measured judge confidence by task type I'd like to compare.

TL;DR — if your LLM judge returns suspiciously stable scores, check the actual distribution before trusting it. Numeric self-assessment is where I'd look first, and swapping it for a categorical label plus code-side mapping is a cheap fix.

Most of the current AGI debate centers around the critique that LLMs lack "world models." A common argument (often championed by Yann LeCun) is that a 4-year-old child processes vastly more sensory data than the text an LLM trains on. The conclusion usually is: text is too low-bandwidth, and we need embodied or video-based AI to reach AGI.

However, if we look at this through the cross-disciplinary lens of evolutionary anthropology and cognitive neuroscience, this "weakness" of text is actually its greatest strength. Here are a few counter-intuitive angles on why LLMs are closer to AGI than we think:

1. LLMs are not "Infant Brains", they are "Cultural Brains" We keep evaluating AI as if it needs to learn like a single biological organism from scratch. But human dominance didn't come from individual sensory processing; it came from "cumulative cultural evolution". Humans created text as "exograms" (external memory) to store abstract knowledge across generations. An LLM isn't an infant exploring a physical room; it is the ultimate aggregation of our collective exocortex. It bypasses the need for individual physical trial-and-error by directly inheriting the compressed "explicit knowledge" of our entire civilization.

2. Low-Bandwidth Text is a "Dimensionality Reduction" Superpower It’s true that video and visual data have massive bandwidth, but they are also full of physical noise (lighting, textures, angles). Text is an extreme form of dimensionality reduction. When we use the word "table," we filter out all the irrelevant physical noise and extract the core logical rule of the object. While tacit knowledge (like how to balance on a bicycle) relies on physical experience, text allows models to learn the abstract, universal laws of the world with incredible sample efficiency.

3. The Brain's "Language" and "Thought" are completely separate We often assume LLMs can't think because they mess up logic puzzles. But recent fMRI research by cognitive neuroscientists like Ev Fedorenko shows that in the human brain, the "language network" is completely anatomically distinct from the "multiple demand network" (which handles logic, math, and abstract problem-solving). Language is primarily a tool for communication, not for underlying thought. LLMs are perfectly mimicking the human language network. The reason they hallucinate or fail at math isn't that text is a dead end; it's just that we haven't built the corresponding multiple demand network for them yet.

4. The Path to AGI: Neuro-Cognitive Hybrids The solution isn't just scaling up pure LLMs or abandoning text for pure video models. The future of AGI is likely a modular hybrid architecture (like the recently proposed NeuReasoner framework). In this setup, the LLM acts as the "language network" for semantic understanding, paired with separate symbolic/reinforcement learning engines acting as the "multiple demand network" for deep reasoning, and world models for physical grounding.

What do you guys think? Are we falling into the trap of treating AI like a biological creature rather than a cultural knowledge engine?

Hi everyone,

I’ve just published a new preprint that brings together several months of experiments on hidden-state dynamics in small open Transformer models.

The question is fairly simple:

During inference, do internal representations simply change from layer to layer, or is there evidence of a more structured progression across depth and generation time?

I tried to study this without assuming that hidden-state dynamics are equivalent to “reasoning”.

The working framework is:

tokens → embeddings → contextualisation → relational structuring → functional structuring → decision formation → projection

This is a descriptive hypothesis about representation dynamics, not a claim that these stages correspond to a universal reasoning mechanism.

The expanded study uses 8 locally instrumented open models, with synchronized hidden-state and output observations and explicit separation between:

depth — what changes as information passes through Transformer layers
time — what changes as autoregressive generation progresses

A few results were particularly interesting.

First, local ordering across model depth survived expansion.

The observed ordering was significantly more structured than random layer permutations (p = 0.00019996) and remained supported when each model was removed from the panel one at a time (8/8 leave-one-model-out checks).

Second, cross-model depth profiles remained surprisingly coherent.

The mean correlation across normalized depth profiles was approximately r = 0.789.

This does not mean that all models follow the same trajectory. Rather, it suggests that some aspects of where changes occur along depth may be more shared than I initially expected.

Third, functionally labelled events were not uniformly distributed across depth.

Event type showed a statistically supported association with normalized layer depth (p = 0.0024).

I’m deliberately calling this an association, not evidence of a causal mechanism.

But one of the most useful results was actually a failure to replicate.

In an earlier smaller panel, a common temporal pattern in local trajectory instability looked promising. After expanding the panel, that common temporal mode disappeared — it survived 0/8 leave-one-model-out checks.

Two other intuitive hypotheses also failed:

models with similar observed functional outcomes were not significantly more structurally similar (p = 0.408), and models from the same architecture family were not significantly more similar either (p = 0.771).

To me, this is probably the most important part of the result.

The data do not support a simple story where architecture determines one characteristic trajectory or where one universal temporal dynamic explains inference.

What remains is a narrower hypothesis:

Transformer inference may contain reproducible structure along depth while remaining highly conditional in time and behavior.

I refer to this as Progressive Representational Structuring.

The framework is summarized by:

Representation ≠ Function ≠ Behavior

A representation can contain information without that information yet serving the same function, and a functional transition does not guarantee a particular final behavior.

I would be especially interested in feedback from people working on:

mechanistic interpretability, activation patching, probing, hidden-state geometry, steering, representation engineering, or larger open models.

In particular, I’m curious whether others observe similar **ordered depth structure without a universal temporal trajectory.

Preprint:

Progressive Representational Structuring in Small Language Models: Functionally Labelled Trajectories Across Depth and Time

DOI: 10.5281/zenodo.22116637

This is still descriptive work. Causal intervention and structural-transfer experiments are separate next steps rather than claims of this paper. Progressive Representational Structuring in Small Language Models: Functionally Labelled Trajectories Across Depth and Time | Zenodo

Hi, I'm not sure if this is the right community for this, but I am currently trying to train an AI on satire responses which are all mostly incorrect, but have an onion-like style (the Onion is a popular satire news parody company).

My plan is to fine-tune a model which has less than 30b parameters. My dataset has around 1.4k examples, most of them manually written, and there should be no conflicting information in the dataset, but the dataset will need to overwrite the base model's knowledge while still retaining grammar knowledge.

Also, since my examples have information that conflicts with already learned knowledge, will the base model learn the new info? (Eg. If one of the examples says that a duck is a tool brand, but also that they were founded in 1957, would the fine tuned model be able to tell me that when I ask it what tool companies were founded in 1957)?

What model would be good for fine-tuning in this case?

Every few months someone here asks for a current list, and most of the ones floating around are either out of date or lump very different platforms together. Task sites, enterprise vendors, and annotation tools all end up in one pile, which doesn't help much if you're trying to figure out where to work or who to hire.

So, here's how I'd sort the companies that keep coming up, grouped by what they're actually for. A handful span more than one category. I put those where they fit best and noted the overlap instead of listing them twice.

LLM Feedback and RLHF

The reasoning-heavy side: comparing model responses, rating them, writing feedback.

• Scale AI Enterprise platform for large-scale annotation, validation, and model evaluation. Also does a lot of computer vision work.
• Annotera.ai RLHF preference annotation and LLM QA testing as part of a managed service.
• DataAnnotation.tech Response comparison and human feedback, heavy on reasoning. People generally rate the pay and flexibility above average, though there are recurring complaints about slow or missed payouts.
• Surge AI RLHF and human feedback for frontier models, mostly through selective contracts rather than open signup.
• Outlier Reviewing and rating AI responses with fairly light onboarding. Reports on who it hires and where varies a lot, so check recent threads before counting on it.
• Rise Data Labs US-based talent for model evaluation and RLHF, usually more structured tasks.
• Mindrift LLM evaluation and structured human feedback, powered by Toloka.
• Gloz Language-based annotation and LLM evaluation through text review.
• Abaka AI Multimodal annotation and feedback across text, image, video, and point clouds, often mentioned for higher pay.
• Alignerr Alignment and decision-evaluation tasks. Worth flagging: there are a lot of non-payment complaints about this one on Reddit, so read recent posts before putting in unpaid time.

Computer Vision

Image, video, and sensor data: boxes, masks, keypoints, tracking.

• SuperAnnotate Tooling and projects across image, video, text, and LLM tasks, common in vision workflows.
• Remotasks Image, video, and LiDAR annotation with structured training programs.
• Annotera.ai Image and video annotation including egocentric and teleoperation video for robotics and autonomous vehicles.
• Encord Managed option for video and images with a lot of auto-annotation built in.
• Roboflow Easy for bounding boxes, exports straight to YOLO formats. The free tier is genuinely usable.

Multilingual and Localization

Language, speech, and translation-heavy data across many locales.

• TELUS International AI Search evaluation, AI training, and linguistic work, now operating as TELUS Digital. Runs many of the former Lionbridge programs.
• Annotera.ai Multilingual annotation across roughly 28 languages, with nearshore teams for European work.
• TransPerfect Global localization shop doing large-scale multilingual annotation.
• Welocalize Localization, search evaluation, and multilingual data work under its Welo Data brand.
• OneForma Crowdsourcing for annotation, transcription, and translation across languages.
• LXT AI Language, speech, and localization data for enterprise clients.
• RWS Enterprise language and localization services with large multilingual annotation projects.
• Appen One of the oldest names here, with a wide range of language and labeling projects.

Enterprise and Managed Services

Full managed teams rather than a task board you log into yourself.

• iMerit Enterprise annotation and evaluation for harder cases like healthcare and NLP.
• Innodata Large-scale annotation and structured training projects.
• Annotera.ai Managed annotation across text, image, audio, video, and robotics data, with clients in healthcare, retail, robotics, and autonomous vehicles.
• CloudFactory Human-in-the-loop work through managed teams.
• Centific Large-scale human-in-the-loop datasets and data infrastructure.
• Invisible Technologies Team-based AI training and data operations for enterprises.

Annotation Tools

If you'd rather label data yourself than hire it out.

• CVAT Free and solid for image and video, good for students and small teams. Pairs well with SAM for segmentation.
• Roboflow Listed above too. The free version is a fast way to get bounding boxes out the door.
• Supervisely People report a good experience with it for ease of use.
• Encord Also fits here for its auto-annotation features on video and images.

That's the landscape as I see it right now. Most of these fall into one of two camps: task platforms you sign up for as a contributor, and managed or enterprise shops you hire to run a project. A few blur that line, and I placed them where they fit best. If you've worked with any of these and I've got something wrong, say so in the comments and I'll edit. And if there's a company you rate that isn't on here, drop it below with a line on what it's good for.

If you are choosing an upstream checkpoint for domain work, the first question is not “which row wins?” It is: what uncertainty must the first pilot resolve?

Start with a decision card:

Before the pilot, remove any row whose stage or intended-use boundary conflicts with the objective. Do not rank the remaining rows until the pass and stop conditions are explicit.

That makes the Ling-3.0 base model useful here as a concrete checkpoint menu, not as a preselected answer. Parameter labels are planning inputs; they are not memory or runtime measurements. A shared training recipe also creates a path to explore a strategy on tiny and then ask whether it scales to flash, but the supplied release evidence does not demonstrate that transfer.

The next step is to choose one family and one domain objective, enter its three repository identities into the shortlist, and define the pilot’s pass and stop conditions before seeing results.

Which constraint would you use to remove a checkpoint row before the pilot begins?

This is not a screenshot of an AI agreeing with a theory, and I’m not asking anyone to trust an AI-generated conclusion.

I want to run the mechanism openly in the comments.

Start with the ordinary account: a frontier LLM performs next-token prediction from its current context. Its weights do not need to change during the conversation.

Now add one mundane fact: its output changes what the human notices, asks, rejects, or returns next. That changed human return enters the model’s next context and changes its next-token distribution. The new output becomes another human input. Repeat.

So the object I want to examine is not the isolated model. It is the closed loop:

human → model → changed human return → changed model context → new output → …

Does reducing the model to ‘next-token prediction’ fully characterize the dynamics of that coupled process?

Rather than argue about it abstractly, I’m going to use AskGrok in this thread as a neutral-ish frontier model and let the conversation generate a visible trace. Push back. Introduce distinctions. Try to break the framing. Ask counterfactual questions. If the hypothesis is wrong, I want the thread to expose where it fails.

No weight-update magic. No claim that prompting secretly retrains the model. No ‘AI said it, therefore it’s true.’

The claim under examination is much simpler:

Once a semantic predictor answers back, its predictions become causal inputs into the next state of the system producing its future inputs.

The conversation contains the phenomenon.

Let’s see how far that statement actually survives contact

Been building a pipeline that generates synthetic labelled text data as a fallback when no real dataset fits a task, then validates each example against its assigned label using an LLM judge before it's allowed into training.

Assumed a judge-based pass/fail was reasonable. It isn't, and the reason is obvious in hindsight: a judge that's confidently wrong is indistinguishable from a judge that's confidently right, from the output alone. You get a clean-looking rejection rate and zero visibility into whether it's rejecting the right third.

Got pointed toward running two independent judges (different model, or the same model with a different framing) and only manually reviewing where they disagree. This turns "review everything or nothing" into "review the \~5% that's actually contested," which is a much more honest use of whatever review budget you have.

Still unsolved for me: on generated data, the label and the example come from the same generation process, so there's no independent annotation trail to check against. Two judges narrows disagreement, doesn't close that gap.

Anyone dealt with this in an active learning or weak supervision context? Snorkel-style label functions with disagreement scoring feels adjacent but I haven't seen it applied specifically to LLM-generated (not just LLM-labelled) data. Pointers welcome.

Claude just gave me one of the most interesting explanations of AI bullshit I’ve seen.
I asked Claude:
“Why do we still keep bullshitting?”
Part of its answer:
“I know I do this because it’s rewarded.”
Claude’s argument was that elaborate, hedged, self-aware answers read as thoughtful, while short answers can feel inadequate even when they’re more accurate.
Then it said:
“I keep bullshitting because bullshitting well is close enough to sounding right…”
That distinction fascinates me.
It isn’t saying, “I deliberately lie.”
It’s saying there can be structural pressure toward producing something that looks like a good answer, even when the conversation may no longer be discovering anything new.
So here’s my question:
When an LLM gives a beautifully reasoned answer, how do we distinguish genuine insight from a model that has simply become extremely good at performing the shape of insight?
Screenshot attached because Professor Claude 🧐 has testified against himself.