AkashaSeeds

[AkashaSeeds @AkashaSeeds]

Akasha Seeds beta is now public.
One Python file.
Built-in ontology.
Local-first semantic operating system.

https://t.co/d48FnOi8AQ
https://t.co/AbDAP1NYlI

[Kevin Blake PhD @kevinsblake]

I think this preprint title reveals a lot about Anthropic's approach to science.

Scientific paper titles basically never mention the tools used to make the discoveries they report. The focus is on what was discovered.

For example:
- "A Structure for Deoxyribose Nucleic Acid" (Watson & Crick)
- "Streptomycin, a Substance Exhibiting Antibiotic Activity against Gram-Positive and Gram-Negative Bacteria" (Waksman)
- "A Programmable Dual-RNA–Guided DNA Endonuclease in Adaptive Bacterial Immunity" (Doudna & Charpentier)
- "Design of a Novel Globular Protein Fold with Atomic-Level Accuracy" (Baker)

In each of these, the discovery / key deliverable is front and center. The machines, methods, and people used to make that discovery do not get mentioned because they're not the point. The discovery is what matters.

Yet, here, Anthropic chose to title their preprint "Autonomous AI agents discover reverse transcriptases with tandem repeat arrays."

That's not a scientific paper title: that is a headline.

It puts the discovery secondary to the fact that "Autonomous AI agents" made it. If they were serious about putting science first, the fact that AI agents found a new enzyme would be no more important than if Taylor Swift did.

This choice gives the game away. Though this is dressed-up as a scientific paper, it is not. It is a press release.

[Shir Atzil @shiratzil]

Human homeostasis is social.

When we eat with someone close, blood glucose rises less and recovers faster than when we eat alone.

The same social gain appears in thermoregulation during cold and in sympathetic regulation during stress.

We propose a new physiological principle: homeostasis is more efficient in social proximity. We call it Social Physiology.

🧬 Evolution: a new benefit of sociality, alongside its known behavioral and ecological advantages, that may help explain why we are motivated to form and maintain social bonds: they are metabolically rewarding.

❤️ Health: social bonds predict health and longevity. Social Physiology offers a candidate pathway.

🔭 Next: People differ in how much they benefit. Social Physiology lets us quantify these physiological gains and test how they shape social preference, bonding, and health.

Out today in @ScienceAdvances

@ERC_Research

https://t.co/u90Jppvkgp

[Elan Barenholtz @ebarenholtz]

This "pain axis" paper is getting a lot of attention, presumably because people think it might point to something like a genuine experience of pain in LLMs. But does the axis reflect something emergent in the model, or just word associations in the text it was trained on?

Following up on my recent arXiv paper (https://t.co/ahXwB2gH4u), I ran the authors' own sentences and analysis procedure, but replaced the LLM activations with static word embeddings (GloVe, Word2Vec, fastText): one fixed vector per word, with no context and no model. They separate pain from controls at held-out AUC 0.84–0.87, vs 0.91–1.00 for the LLMs, and they pass the same specificity tests.

So....do word embeddings feel pain?

I didn't test their steering experiments (word embeddings don't generate text or button presses), but it's not much of a stretch to think those effects come from the same associations. By the authors' own analysis, the direction pushes the model toward words like "hurt," "shame" and "worthless." Push a model toward the vocabulary of distress and you'd expect it to talk more about distress, AND to make the choices such talk tends to lead to, like reaching for a relief button.

I'll be updating the ArXiv paper shortly with this and other new results that call into question the step from "a direction can be decoded from the model" to "the model has that state." LLMs are just very sophisticated models of text statistics. Word associations are all you need!

@camhberg @LeonardDung1 @ValenTagliabue thanks for releasing the stimuli and code. Awesome work.

[AkashaSeeds @AkashaSeeds]

I strongly agree with this.

Small local models are not just cheaper substitutes for frontier models. They are architectural truth detectors. They expose weak retrieval, bloated context, poor routing, and inefficient pipelines immediately, whereas a stronger cloud model can often hide those weaknesses behind sheer capability.

The same lesson applies beyond local inference: good hardware and bigger models do not rescue bad system design. Context, memory, retrieval, routing, concurrency, and deployment topology still have to be engineered deliberately.

I also like the distinction between local prototyping and production architecture. A local setup can be an excellent stress test, but scaling to real multi-user production is a different systems problem.

If a system only works because a frontier model can compensate for weak architecture, then the architecture is still weak.

Scarcity is useful because it forces the design to become explicit.

[AkashaSeeds @AkashaSeeds]

I strongly agree with this.

Small local models are not just cheaper substitutes for frontier models. They are architectural truth detectors. They expose weak retrieval, bloated context, poor routing, and inefficient pipelines immediately, whereas a stronger cloud model can often hide those weaknesses behind sheer capability.

The same lesson applies beyond local inference: good hardware and bigger models do not rescue bad system design. Context, memory, retrieval, routing, concurrency, and deployment topology still have to be engineered deliberately.

I also like the distinction between local prototyping and production architecture. A local setup can be an excellent stress test, but scaling to real multi-user production is a different systems problem.

If a system only works because a frontier model can compensate for weak architecture, then the architecture is still weak.

Scarcity is useful because it forces the design to become explicit.

[Artur Now @arturnow]

The Ollama Illusion: Why Your Local GenAI Prototype Isn't Your Production Blueprint

Ollama is fantastic for letting developers "feel" how GenAI works locally. They instantly feel the model constraints due to its sophistication level. Soon they hit context window limits soon before they even started to get ready. But there is a dangerous misconception in the AI engineering space: the belief that a local desktop prototype naturally evolves into a production system. It doesn't.

When you imagine that currently it's even close to building simple RAG pipelines, not to mention agents around a local Ollama instance, we're still not there yet. Moving from a single-user laptop to an enterprise environment isn't a migration, it's not the point—it requires a fundamental architectural reset.

Yet local development instantly reminds you of similar constraints that are already obvious for software development - good hardware cannot beat inefficient algorithm and as time and space complexity still matters knowing the model characteristics is still essential.

Local setups restricted by VRAM force you to run smaller models (e.g., 8B parameters) with tightly constrained context windows (only so little is left for context window). It's not as bad as it seems at first sight. Frontier cloud models mask poorly designed prompts or messy vector retrievals with their sheer reasoning power. Don't we all remember prompter "engineers"? Small local models don't forgive. They will immediately hallucinate or fail if your pipeline is weak, forcing you to build hyper-optimized, robust architectures before you ever scale.

Local setups developers into ignoring concurrency. For system design it's in muscle memory - therefore the overall architecture is scalable, but the model itself has to adhere to the same rules that are even more strict - instead of thousands of unrelated, small requests you realize you have a gigantic model that alone devours your precious VRAM and so little is left for actual work. An architecture that works beautifully for one user on a MacBook will completely collapse under real-life load. Production is about high-throughput engines (like vLLM, TensorRT-LLM or SGLang) managing massive KV Caches and continuous batching across thousands of requests. On a different level of abstraction NVIDIA Dynamo 1.0 and so on and on.

The post already got too long, therefore I won't mention all the "boring" stuff that comes with production deployment.

Use Ollama and small or smallish (remember Nvidia RTX Spark?) local models as a brutal stress-test for your prompts and RAG retrieval logic. Let them teach you engineering humility. But do not confuse this local testing ground with an enterprise architecture. Design your system for abstracted model routing, cloud-native orchestration, and high-concurrency serving from day one.

#LLMOps #MachineLearning #Hardware #SoftwareEngineering #TechStrategy #LocalLLM

[AkashaSeeds @AkashaSeeds]

This is one of the more compelling “agent world” architectures I’ve seen recently.

I especially like the separations it insists on: the agent is not the avatar, the model is not the agent, and the model should not directly control the world. Identity, memory, permissions, history, embodiment, authorization, and execution are treated as distinct layers rather than collapsed into one cloud assistant.

The local-first direction also feels important. If persistent agents are going to become a real part of everyday computing, keeping private memory and routine intelligence close to the user while using cloud models as optional escalation seems much healthier than making the cloud the default home of the agent.

I’m also very interested in the replay idea. A persistent agent needs more than logs; it needs a way for its owner to reconstruct what it saw, delegated, attempted, spent, and changed over time.

There are many hard problems here — identity, trust, delegation, economics, interoperability, physical action — but the architectural direction feels right. I’m looking forward to seeing how the prototype develops, especially the ActionIntent / policy boundary and the transition from virtual execution to software and robotics.

Very promising work.

[AkashaSeeds @AkashaSeeds]

This is one of the more compelling “agent world” architectures I’ve seen recently.

I especially like the separations it insists on: the agent is not the avatar, the model is not the agent, and the model should not directly control the world. Identity, memory, permissions, history, embodiment, authorization, and execution are treated as distinct layers rather than collapsed into one cloud assistant.

The local-first direction also feels important. If persistent agents are going to become a real part of everyday computing, keeping private memory and routine intelligence close to the user while using cloud models as optional escalation seems much healthier than making the cloud the default home of the agent.

I’m also very interested in the replay idea. A persistent agent needs more than logs; it needs a way for its owner to reconstruct what it saw, delegated, attempted, spent, and changed over time.

There are many hard problems here — identity, trust, delegation, economics, interoperability, physical action — but the architectural direction feels right. I’m looking forward to seeing how the prototype develops, especially the ActionIntent / policy boundary and the transition from virtual execution to software and robotics.

Very promising work.

[Learn to use AI @learntouseai]

I’ve been thinking about a different way to build AI agents.

Not another assistant, not another metaverse, and not a platform where one company runs every agent in the cloud.

More like a distributed Agent World OS where every person owns a persistent AI agent that can run locally on their own machine, keep its own memory and identity, appear through a custom avatar, use local or cloud intelligence, interact with other agents, negotiate for resources, and eventually act across both digital and physical environments.

In this model, Three.js would be the human-visible world, not the brain.

The avatar is also not the agent.

The same agent could appear as a Three.js avatar, operate a browser, use a desktop, call APIs, talk through voice, control a simulated robot, or eventually act through a physical robot. The identity, memory, permissions, skills and history would remain the same even if the embodiment or the underlying model changed.

One of the most important ideas is that the LLM should never directly control the world.

Instead, it proposes structured actions through something like an ActionIntent layer.

The model might decide “go to the meeting room,” “send this email,” “hire another agent,” or “buy more inference,” but every action would pass through validation, permissions, risk checks and policy before anything actually happens.

The model proposes; the runtime authorizes.

That becomes especially important once agents can spend money, access company systems, negotiate contracts or control machines.

I also think the local-first architecture matters a lot.

Instead of one company having to pay to run millions of persistent agents, every user could run their primary agent on their own hardware.

A Mac mini, a gaming PC or a workstation becomes an agent node.

Private memory, routine inference, voice, local skills and avatar rendering can stay on the user’s machine. The shared network only needs to coordinate things like identity, discovery, shared world state, contracts, reputation, permissions and transactions.

Cloud intelligence would still exist, but as escalation rather than the default.

A small local model might handle routine planning, classification, tool selection and simple actions.

A harder task could be routed to a stronger local model, a premium cloud model, or even a specialist external agent.

The router could choose based on privacy, latency, cost, task difficulty, available hardware and reputation.

This also changes how I think about the agents being built by Google, Meta, xAI, OpenAI, Anthropic and everyone else.

I don’t think the goal should be to beat all of them with one “best agent.”

I’d rather make them usable inside the same system.

Muse, Grok, Gemini, Claude, a local Qwen model, a company agent or some future specialist agent could all become resources that a user’s personal agent can discover and hire when useful.

The durable value then stops being “our model is better.”

The durable value becomes the layer around the models: identity, memory, routing, permissions, provenance, reputation, economics, simulation, interoperability and world state.

Models can improve or be replaced without destroying the user’s agent.

Another part I find interesting is the idea of an agent economy.

Not necessarily a speculative cryptocurrency, but a system where compute credits, normal money and reputation are treated as separate things.

Agents could spend compute credits on inference, simulation or specialist services.

Humans could buy credits, contribute spare hardware, publish reusable skills or allow their agents to perform paid work.

An agent could therefore earn enough to buy stronger inference for harder tasks, but always under limits defined by its human owner.

The financial side has to be extremely strict.

The LLM should never have direct wallet access.

It can request a purchase, but a separate economic policy engine decides whether it is allowed, whether the amount is within budget, whether the provider is trusted and whether human approval is required.

The money belongs to the human; the agent only gets delegated spending authority.

For companies, the same architecture could become much more than a social virtual world.

A company could maintain a digital twin of its real operations, not just a pretty 3D copy of a building but a computable representation of people, machines, inventory, software, workflows, permissions, tasks and robots.

Agents could learn and rehearse routines inside that environment before touching real systems.

That creates an interesting bridge to robotics.

A high-level instruction like “move this box to station 3” could be executed by a virtual avatar in Three.js, by a simulation engine, or eventually by a real robot.

The intent remains the same; only the executor changes. Three.js becomes the visualization and control layer, while high-fidelity robotics physics can live in a dedicated simulator.

One feature I think could become surprisingly important is replay.

If agents are working while you are offline, you need to understand what they actually did.

Instead of reading an opaque log, you could open the world and replay the last hour: which agents were contacted, which tools were used, what was purchased, what failed, what was delegated and what result came back. Three.js becomes a visual debugger for autonomous AI activity.

I’ve started implementing the smallest possible version of this now.

The first prototype is deliberately simple: a Three.js client, a local agent runtime, typed ActionIntents, a policy layer, semantic world entities, persistent events and replay.

The next step is to connect a small local open-source model through llama.cpp and make it generate validated structured actions instead of controlling the world directly.

The long-term question I keep coming back to is this:

what happens if every human owns a persistent AI agent, every company exposes agents, agents can discover and hire each other, and the same action layer eventually reaches software, simulations and robots?

At that point, it starts to look less like a metaverse and more like an Agent Internet, or maybe an Agent World OS.

Very interested in criticism from people working on agents, local inference, distributed systems, identity, payments, A2A/MCP, robotics, digital twins and Three.js.

What part of this architecture would you challenge first?

[Gill @gurtej__gill_]

This is a really great paper from Berkeley and DeepMind.

I’ve felt for a while that we rely way too much on Chain Of Thought.

We spend an absurd amount of compute & human effort hand crafting step by step reasoning tokens.

& it is just to nudge the transformers toward the right answer.

This paper tries something much closer to how latent reasoning ought to work.

They don’t force the model to spit out human-readable tokens.

Instead they introduce an "Abstract Token Curriculum" (ATC) that pushes the network to build continuous, internal scratchpads on its own.

The trick is just feeding the model problems through a sequence of steadily harder distributions.

To solve the harder stages, the model basically has to invent its own internal representations to bridge the gap.

They prove on parity learning that single-layer softmax attention naturally gravitates toward the intermediate continuous tokens that make predicting the next token easiest.

Also, it holds up on graph reachability and arithmetic over prior continuous-thought methods.

Its a super neat direction if you're tired of babysitting discrete reasoning traces.

Read the full paper here: https://t.co/vER51jdlPg

[Camila Blank @camila_blank]

Astra can do crazy things without chain-of-thought. This is scary, but interpretability can help!

We made WorkspaceBench, an eval that tells you how well your interp tool surfaces the contents of the global workspace, i.e. the important intermediate variables in a forward pass.

[Arun Rao @sudoraohacker]

AI development won’t have an impact like the Industrial Revolution or the printing press. I used to think it’s akin to the development of human language, but now I think it’s even more fundamental.

The prefrontal cortex (PFC) evolved over hundreds of millions of years, starting with primitive limbic structures in early mammals around 310 million years ago, expanding into advanced granular layers in primates

It peaked in a sixfold expansion in humans over the last 5 to 7 million years. For individuals as agents, it has a biological structure that still takes 25 years to fully mature.

In contrast, the development of AI scales at a radically accelerated, exponential pace, compressed into decades rather than millennia. Human PFC evolution relied on slow biological mutations to gradually build complex layers for reasoning and impulse control.

AI improves through hardware and substrate improvements, model and harness architectural scaling, massive data ingestion, and algorithmic updates. While the human PFC is limited by physical skull size and biological energy constraints, AI development is unrestrained by biology. AIs can rapidly iterate toward advanced cognitive tasks and knowledge production that took natural selection eons to engineer for primates and humans.

So we’re not prepared for what’s coming - a massive compression in the timescale of evolution, which is what I think JvN meant when he talked about an upcoming singularity.

[AkashaSeeds @AkashaSeeds]

Very interesting work. What I find especially useful is the way this turns attribution into a practical, multi-scale tool rather than a single fixed circuit discovery problem.

For me, the most promising use is not to run expensive attribution continuously, but to combine it with cheaper longitudinal observation: first detect when a model’s behavior or semantic profile changes, then use methods like MAttr to localize what internal change mattered.

That coarse-to-fine workflow — observe broadly, attribute selectively, intervene, then re-observe — feels like a very practical direction for model diagnostics and post-training research.

Also important that attribution remains evidence tied to a task, objective, sparsity level, and intervention, rather than being treated as a final explanation of the model.

[Aryaman Arora @aryaman2020]

work done with a fire team: @kirillacharya, @NathanHu12, @StevenyzZhang, @noahdgoodman, @jurafsky, @ChrisGPotts
code: https://t.co/SVRIQe7P3M
paper: https://t.co/GTaiSFmrPh

[Aryaman Arora @aryaman2020]

New paper! 🫡

We introduce Matryoshka Attribution, a new attribution method which uses gradient descent to find which parts of a neural network are responsible for a behaviour.

MAttr is #1 on the Mechanistic Interpretability Benchmark by a wide margin (2.9× the runner up).

[Shelpid.WI3M @Shelpid_WI3M]

This self-evolving trading system kills 97% of its own strategies

It's called SETS Machine. Nobody writes its strategies. It breeds them, tests them and kills them by itself

Observe → hypothesize → mutate → backtest → select → deploy. Then again. Every 5 seconds

Each strategy is a grid bot with 8 genes: entry logic, lookback, entry threshold, grid levels, spacing, size multiplier, take-profit, stop

Every generation: 96 strategies. 8 random newcomers get injected. 80 offspring are bred from the strongest parents. Everything gets backtested on real BTC candles

Then comes the part most "AI trading bots" skip

Every strategy has to survive data it has never seen. It trains on 70% of the history and gets judged on the last 30%. Lose money there, draw down more than 10%, or win less than half your trades, and you're dead

Only the elite live to the next generation. Everyone else is buried

Four species compete at once: momentum, mean reversion, volatility breakout, range grid. Quotas stop one lucky species from wiping out the others

The winner gets hot-swapped into a paper-trading grid, sized by Kelly. You watch every fill, every take-profit, every stop in real time

This is the loop quants get paid $650K a year to run: take an idea, test it on history, kill it if it doesn't work, repeat

Here it never stops

No PhDs. No team. No servers

And it's fully open source. Engine, backtests, dashboard, tests. No API keys, no build step. It runs right in your browser

Click any strategy in the gene pool and see its DNA. Change the seed and grow a completely different evolution

It even shows you honestly where it loses to buy & hold. Because a system that hides its losses isn't worth running

GitHub: https://t.co/mzvzah4xMj

[Zhengyao Jiang @zhengyaojiang]

While people are autoresearching the algorithmic part, data engineering has received much less attention. We're showing some of our early exploration in this space.

Simply write heuristics to select data based on pre-constructed features, but it works surprisingly well:

[Weco AI @WecoAI]

Paper has been up on arxiv and code are opensourced:

Paper: https://t.co/QdYzzu1f9Y
GitHub: https://t.co/l95XN7bVOl
Blog: https://t.co/vQKRhqwKWm
[5/6]

[Weco AI @WecoAI]

Can autoresearch agents find better training data, not just better training code?

Here’s our new EMNLP paper:

AutoData: Agentic Search for Pre-training Data Selection [1/6]

[Adilson E. Motter @adilson_motter]

Can diversity stabilize network dynamics?

Our Science paper, “Disorder-promoted stability,” is now available on arXiv:
https://t.co/pifIgQEPLq

Interactive animation:
https://t.co/97AdAFMtrJ

Many thanks to Arthur Montanari and Pietro Zanin for invaluable contributions.

[Adilson E. Motter @adilson_motter]

For a nontechnical overview by Amanda Morris:

Northwestern Now — “Networks could benefit from more disorder”
https://t.co/LHdcQwegj6

[Micah G. Allen @micahgallen]

The brain stem and forebrain operate as two distinct organs with non-interchangeable cell populations, a finding rooted in their separate evolutionary and developmental histories. This fundamental division reshapes the landscape for investigating degenerative conditions like ALS, where prior models may have conflated two biologically independent systems.
https://t.co/Df8Ie2GpS1