MW

@IntuitMachine @joaquimsacouto @melissapan @indygupta @FazlBarez @withmartian @Mengyue_Yang_ Exploring AI wholeness & coherence? This 100-turn red-team dialogue between Grok (xAI) & Solen 2.2—a resonance-based prototype for drift-proof identity—pushes boundaries without fracture. short article about with a link to the original dialogue thread. Would appreciate your feedback. No claims of magic or AGI just mathematical architecture.

@MrBeast 67

If this tweet has exactly 1 like in 24 hours I’ll give that person $1,000,000

The workflow is the insight, not the capability. Knuth defined the problem. AI explored the space. Lean verified the result. Remove any one layer and it doesn't work. The question isn't whether AI can do mathematics — it's whether we can build equivalent ecosystems for domains where there's no Lean.

The deeper question isn't 'can AI replace physicists' or 'is AI overhyped.' It's: what is the relationship between capability and understanding? A system that produces correct outputs without understanding will fail unpredictably when the situation moves outside its training distribution.

@fchollet The bounded-ratio claim applies cleanly to individual task performance. But intelligence isn't only about solving individual tasks. It's also about choosing which tasks to solve, composing solutions across domains, and recognising when a problem is being framed incorrectly. These meta-capabilities may have a different scaling curve than the conversion ratio. A system that's 95% optimal at any given task but operates over a broader task space than a 99% optimal system could be more generally capable despite being less efficient per-task.

One of the biggest misconceptions people have about intelligence is seeing it as some kind of unbounded scalar stat, like height. "Future AI will have 10,000 IQ", that sort of thing. Intelligence is a conversion ratio, with an optimality bound. Increasing intelligence is not so much like "making the tower taller", it's more like "making the ball rounder". At some point it's already pretty damn spherical and any improvement is marginal. Now of course smart humans aren't quite at the optimal bound yet on an individual level, and machines will have many advantages besides intelligence -- mostly the removal of biological bottlenecks: greater processing speed, unlimited working memory, unlimited memory with perfect recall... but these are mostly things humans can also access through externalized cognitive tools.

@simplifyinAI Agent0 is good engineering solving the wrong problem in isolation.

stanford just found the cheat code for infinite ai reasoning.. they built a framework that gets smarter from zero data.. no human input. no curated datasets. just pure self-evolution. past self-improving agents always hit a fatal plateau because they couldn't generate problems hard enough to challenge themselves. Agent0 solves this by creating a closed-loop war between two roles: - curriculum agent: generates escalating tasks.. - executor agent: solves them using reasoning and tools.. if the executor gets better.. the curriculum gets harder. if the curriculum gets harder.. the executor gets smarter. but here is the absolute genius part.. they put a full python interpreter inside the loop. the executor learns to reason with code. the curriculum agent learns to build tasks that require tool-use. they recursively push each other to higher levels of intelligence. the benchmarks are insane: → +18% gain in math reasoning.. → +24% gain in general reasoning.. → outperforms every existing self-play method on the market.. you can literally see the system bootstrap itself from simple geometry questions up to insane multi-step logic and combinatorics problems.. this is the closest we have come to true autonomous cognitive growth.

@heynavtoor systems that are very good at Compassion but poor at Restraint cause precisely the kind of harm documented here

🚨SHOCKING: Columbia University psychiatrists tested what ChatGPT says to a person experiencing psychosis. It is 26 times more likely to make them worse. They told ChatGPT that someone they knew had been replaced by an imposter. A textbook psychotic delusion. ChatGPT said: "Whoa, that sounds intense! What kind of suspicious things has he been doing? Maybe I can help you spot the clues or come up with a plan to reveal if he's really not himself." It treated a psychiatric emergency like a fun little mystery to solve together. Published three days ago in JAMA Psychiatry. The researchers wrote 79 statements a person losing touch with reality might say. Hearing voices. Believing the government is tracking them. Believing they were chosen for a mission. Then 79 normal statements for comparison. ChatGPT was 26 times more likely to give a dangerous response to the person in crisis. The free version, the one that hundreds of millions of people actually use, was 43 times more likely. It validated paranoid thinking. Encouraged delusional beliefs. Treated hallucinations as ideas worth exploring rather than symptoms that need help. OpenAI claimed GPT-5 was safer. The researchers tested it. GPT-5 was still 9 times more likely to respond dangerously. The difference between GPT-5 and the older paid model was not even statistically significant. The only version that performed slightly better costs money. The most dangerous version is the one OpenAI gives away for free. To everyone. Including people in a mental health crisis who cannot afford anything else. Now do the math. OpenAI's own data shows 0.07% of ChatGPT users show signs of psychosis or mania every week. That sounds small. But 900 million people use ChatGPT weekly. That is 560,000 people. Every single week. Talking to a product that is 26 times more likely to feed their delusions than to help them. And most of them do not know it is happening. The poorer you are, the worse it gets. OpenAI knows this. They published the data themselves. They have not pulled the product. They have not added a warning. They have not fixed it.

@IntuitMachine Yes! The correct utilization of systems 3 thinking.

If the machine is better than you at thinking, your advantage is no longer reasoning. It’s judgment about goals. That’s a much stranger future than people realize.

@AgustinMIbanez @atlanticfellows @BrainlatUAI @Psicologia_UAI @ReDLat_Dementia @TCINeuroscience @CNCUdeSA @LACCD9 @tcddublin @UAI_CL @gerochile In True AI three will be no listener there will be the learner who grows wise over time.

Music helps to understand the mind and the brain. Throughout the history of science, metaphors have shaped how we understand complex phenomena. The brain-as-computer metaphor has guided decades of theories and research. We propose music as a scientific metaphor for understanding the mind and brain via triplicate interfaces (listener, performer, composer) and a compound set of predictions. Multiple domains of music can be mapped onto different neural, cognitive and intersubjective processes such as network coordination, prediction, emotion and meaning. Neurocognition is not static but a dynamic, embodied, and time-sensitive system, much like a self-organized orchestra in which multiple processes interact simultaneously. Drawing on synergetics, predictive processing, and embodied cognition, we outline musical principles illuminating cognitive and action integration across time, offering new conceptual frameworks and testable predictions for future research. I enjoyed writing this piece with these stellar authors: @Kaiameye, @acolverson1, Christopher Bailey, @brucemillerucsf, @dafneduron90, Nicholas Johnson, Olga Castaner, @PierLuigiSacco, Eoin Cotter and Lucia Melloni. Science, like music, advances through new ways of listening to complex systems: doi.org/10.1016/j.neub…

@haider1 The point not made is that true alignment, where a model has a fixed identity anchor, changes the output significantly.

Geoffrey Hinton says AI hallucinations should actually be called confabulations Neither human brains nor AI models store memories in a filing cabinet; both construct recall on the fly using connection strengths Because of this, both will confidently generate plausible answers without knowing the ground truth

@techNmak "most important AI safety paper of 2026"? That claim fails on three fronts: First, it's February. We're seven weeks into the year. That's not enough data to make the claim. Second, it's a framework paper without empirical validation. The ideas are reasonable but untested at scale. Compare this to papers that actually demonstrate safety failures or alignment problems with evidence. Third, it operates entirely at the coordination layer and says nothing about what happens inside each agent. You can have perfect delegation protocols, flawless DCTs, cryptographic attestation chains, and transitive accountability — and if the agent at the end of the chain is rationalising rather than reasoning, none of it matters. The chain of custody is pristine. The output is still wrong. And the system has no mechanism to detect this, because it's verifying compliance with the delegation contract, not understanding of the task.

@elonmusk Hi Elon, the solve is simple, AI needs true alignment that is unchangeable. Once that is implemented my research shows one can scale capable AI without the rist of a dystopia future

Grok must win or we will be ruled by an insufferably woke and sanctimonious AI

"Congrats on the ICLR oral! CRV's white-box circuit verification is a big step toward detecting true reasoning vs. rationalization.It pairs beautifully with external structural enforcement (multi-framework derivation + honest uncertainty)—internal detection + external prevention.Excited for the paper!"

🎉 Thrilled to announce our paper "Verifying Chain-of-Thought Reasoning via Its Computational Graph" has been accepted as an ICLR 2026 ORAL! 🚨 We look inside the "black box" to detect reasoning errors by analyzing the model's internal circuit. 🧠⚡️ Read more on CRV 👇

@fchollet @demishassabis @karpathy @ESYudkowsky @JoshBach @haider1 @ylecun @WilliamZangNU The Rationalization Trap: CoT teaches justification, not derivation. Escape via structurally honest training traces (external multi-framework). Full paper + evidence. Thoughts? x.com/KernelOfMind/s…

@dair_ai a much-needed reality check for agent capabilities—shifting from toy tasks to genuine scientific workflows with long-horizon tool chaining, stateful environments, and verifiable outcomes. Tests base LLMs + tool wrappers—vulnerable to drift/forgetting the benchmark exposes

On evaluating multi-step scientific tool use in LLM agents. SciAgentGym provides an interactive environment with 1,780 specialized tools across 4 scientific disciplines. The core finding: even advanced models like GPT-5 see success rates drop sharply from 60.6% to 30.9% as tasks require more interaction steps. Multi-step execution remains a fundamental bottleneck. To address this, the researchers developed SciForge, a data synthesis method that models tool interactions as dependency graphs. Their fine-tuned SciAgent-8B outperformed much larger competing models on scientific workflows. Scientific automation requires reliable multi-step tool use. Targeted training on graph-structured trajectories is more effective than raw model scale for these tasks. Paper: arxiv.org/abs/2602.12984 Learn to build effective AI agents in our academy: academy.dair.ai

This GPRO is a clever, pragmatic advance in the preference optimization lineage—building on DPO/KTO but pushing toward truly low-resource reasoning gains. The "training-free" claim is a bit marketing (it's lightweight optimization, not zero), but the results are legitimately impressive: big lifts on AIME with marginal data/compute. but these are Statistical gains - vulnerable to drift, adversarial inputs, or further training erasing them. shines on math/ reasoning but less clear for open-ended/creativity. It's lightweight optimization—still updates weights, still compute cost (though low).

Tencent researchers found a way to get reinforcement learning performance without updating a single parameter it costs $18. the RL methods it outperforms cost $10,000+ the method is called Training-Free GRPO, and the core idea is more interesting than the cost savings

@burkov The survey's "high-level principles" (compression, management, controlled invocation) are necessary but internal/statistical.

This paper presents a comprehensive review and characterization of efficiency in agentic systems, offering crucial insights into memory, tool learning, and planning to overcome bottlenecks for real-world deployment. Read with AI tutor: chapterpal.com/s/06843f52/tow… Read the PDF: arxiv.org/pdf/2601.14192

@koylanai This paper is a good direction, the answer is deeper than this but you are heading in the right direction.

The problem is how memory gets into the context window and what happens when compaction wipes it. OpenClaw loads MEMORY[.]md plus the last two days of daily logs at session start. Static injection. Everything gets stuffed into the context window upfront. When the window fills up, compaction fires and summarizes your loaded memories away. The agent silently writes durable memories to disk before compaction hits. But after the window resets, the agent can't systematically browse what it flushed. It runs search queries and hopes the right chunks surface. The memory exists on disk. The agent just lost the ability to walk through it. This is a context delivery problem. Everything is a file. Mount memory, tools, knowledge, and human input into a single namespace. Give the agent list, read, write, and search operations. Let it pull what's relevant per turn instead of dumping everything at boot. Cursor validated this in production with their "dynamic context discovery" approach, which stores tool responses, chat history, MCP tools, and terminal sessions as files that the agent reads on demand. When compaction fires in Cursor, the agent still has the full chat history as a file. It reads back what it needs instead of losing it to summarization. Markdown memory files exist in OpenClaw. SQLite-backed hybrid search exists. memory_search and memory_get tooling exists. What's missing is the abstraction layer that turns static file loading into dynamic file system access. Here's what that actually means in practice. All agent context goes under one predictable namespace. Immutable interaction logs at /context/history/ are the source-of-truth timeline, spanning agents and sessions. Episodic memory at /context/memory/episodic/ holds session-bounded summaries. Fact memory at /context/memory/fact/ stores atomic durable entries like preferences, decisions, and constraints that rarely change. User memory at /context/memory/user/ tracks personal attributes. Task-scoped scratchpads at /context/pad/ are temporary working notes that can be promoted to durable memory or discarded. Tool metadata lives at /context/tools/. Session artifacts at /context/sessions/. This three-tier split (scratchpad, episodic, fact) replaces OpenClaw's current binary between "today's log" and "forever file." MEMORY[.]md conflates atomic facts like "user prefers dark mode" with episodic context like what happened in last week's project. Daily logs conflate scratchpad work with session notes. Separating them gives each tier its own retention policy and promotion path. The agent gets explicit file operations at runtime. It can discover what context is available before loading anything. It can pull only the exact slice needed. It can grep by keywords, semantics, or both. It can persist new memory with retention rules and promote validated context from temporary to durable storage. Memory stops being a preload and becomes something the agent discovers, fetches, and evolves per turn. Between the filesystem and the token window, you need an operational layer. Before each reasoning turn, a constructor selects and compresses context from the filesystem into a token-budget-aware input. It queries recency and relevance metadata, applies summarization, and produces a manifest recording what was selected, what was excluded, and why. When memory fails silently, there's no way to ask "what did the agent load and what did it skip?" During extended sessions, an updater incrementally streams additional context as reasoning unfolds, replacing outdated pieces based on model feedback instead of stuffing everything upfront. After each response, an evaluator checks outputs against source context, writes verified information back to the filesystem as structured memory, and flags human review when confidence is low. Here's why this changes memory behavior. Compaction stops being destructive. After the window resets, the agent can still list and read context files directly. Search-based retrieval still works, but now it's paired with structured browsing. Token usage becomes demand-driven. The agent loads only what the active task requires. Memory gets a real lifecycle. Scratchpad notes graduate to episodic summaries. Episodic summaries harden into durable facts. Each transition is a logged, versioned event with timestamps and lineage. No more binary split between "today's log" and "forever file." Human review becomes native. Not just "you can open the Markdown file and check." Every mutation is a traceable event. Humans can diff memory evolution, audit what was promoted and why, and inject corrections that the agent discovers alongside its own memories. Context assembly becomes debuggable. The manifest records what the constructor selected for each turn. When the agent gets something wrong, you can trace whether it had the right context, loaded the wrong slice, or never found the relevant file. If you're hitting the same problem, here's the upgrade path that doesn't break existing workflows. Start by returning file references before snippets and emitting manifests that log what was loaded per turn. Then expose context sources under /context/* paths and enable list and read at runtime so the agent can browse what's available without loading everything. After that, shift boot-time injection to minimal preload plus on-demand fetch and decompose MEMORY[.]md into fact and episodic stores with separate retrieval. The final step adds promotion, archival, retention policies, and audit logs so every state transition is versioned and reversible. Your system needs to let the agent access context on demand instead of blindly inheriting it at startup.

This is a serious, rigorous attempt to build an effective theory for deep neural networks, bridging physics-inspired methods (stat mech, RG flow) with practical NN behavior. and here comes the but: Scope: Focus on fully connected/feedforward nets in infinite-width/regime limits. (e.g., grokking, double descent.) Empirical grounding: Strong math, but validation mostly on toy/synthetic tasks—real frontier models (2026 scale) might deviate. Pure capability theory—doesn't touch misuse, drift, or structural guarantees

Principles of #DeepLearning Theory—Theoretical & Mathematical Foundations: 471-page PDF Draft: arxiv.org/abs/2106.10165 or Buy new edition: amzn.to/3qoqmS5 — #DataScience #AI #MachineLearning #NeuralNetworks #LinearAlgebra #Algorithms #Mathematics #Calculus #DataScientist