AyrésMàcruby🥨

Með ærslum leikur á strengi og flúðir
Og glettinn skvettir á gráan stein

[Lilian Weng @lilianweng]

new post on harness engineering for AI self-improvement: https://t.co/ZYvGfVs61k

It is hard to forecast how much the future of RSI will rely on harnesses. Likely harness engineering will evolve in the direction of self-improvement and enable auto-research, and, in turn, smarter models keeps harnesses simple.

Even when many harness improvement get eventually internalized into core model, the need to specify goals and context will not disappear.

[Thariq @trq212]

https://t.co/hPiZr1kG7r

[Math Cafe @Riazi_Cafe_en]

Cornell's Algorithmic Game Theory 2025
by Eva Tardos

Lecture notes: https://t.co/YsfUXSyTno

[Aron厚玉 @aronhouyu]

https://t.co/18Nu2mQ9a2

[Fei-Fei Li @drfeifei]

https://t.co/Kt50ttQRMJ

[Thariq @trq212]

https://t.co/R6exTuF7P8

[Minara AI @minara]

Quant trading is solved.

Introducing: Minara Strategy Studio.

Design strategies, backtest, compare PnL, avoid brutal drawdowns, optimize parameters, go live, all in plain words.

Join the closed beta: https://t.co/RClebUHKm1

🧵

[Movez @0xMovez]

This 30-min workshop by the creator of Claude Code will teach you more about vibe-coding than 100 YouTube video guides.

Bookmark it & give it 30 minutes today. This video will change the way you use Claude forever.

[Vaidehi @Ai_Vaidehi]

Here are the 3 Core Pillars of Every AI Agent's Context

Here's why MCP, RAG and Skills are now unavoidable...

Before we dive in, here's why all 3 exist in the first place:

Every AI Agent struggles with 3 core problems:

- Connecting to external tools requires writing custom API code every time
- Answering accurately from knowledge it was never trained on
- Repeating the same instructions in prompts; wasting tokens on every single call

MCP, RAG, and Skills were each built to solve exactly one of these problems.

📌 1\ MCP (Model Context Protocol)

MCP eliminates the need to write custom API integration code every time your agent needs to connect to an external tool.

How it works:

- User sends a query → MCP Client selects the right server
- LLM processes the request and routes it to the MCP Server
- Server (Slack, Qdrant, Brave Search) responds with the relevant data
- Final output is returned back to the user

Key insight: Without MCP, every new tool connection means new custom code. With MCP, your agent plugs into any server through one standardized protocol.

Use when: You want your agent to access external tools and services without rebuilding integrations from scratch each time.

📌 2\ RAG (Retrieval Augmented Generation)

RAG gives your agent memory-enabled retrieval, so it reasons over knowledge it was never trained on, instead of hallucinating answers.

How it works:

- Data sources are chunked → converted into embeddings
- Stored as dense vectors inside a Vector DB
- User query triggers a search → most relevant chunks are retrieved
- Retrieved info + query + system prompt → fed into the LLM → Output

Key insight: Without RAG, agents confidently make things up. With RAG, they retrieve first, then reason.

Use when: You want your agent to reason over large, dynamic knowledge bases with accuracy and context.

📌 3\ Agent Skills

Skills stop your agent from wasting tokens by repeating the same instructions in every single prompt.

How it works:

- User query → LLM sends a Skill Request to the Skill Manager
- Skill Manager retrieves the right skill using stored prompts and actions
- Tools like Git, Docker, Python Interpreter, and Shell are triggered
- Skill data flows back to the LLM → Final Output is delivered

Key insight: Without Skills, you bloat every prompt with repeated instructions. With Skills, your agent loads only what it needs, exactly when it needs it.

Use when: You want reusable, token-efficient actions your agent can execute without being re-instructed every time.

Save 💾 ➞ React 👍 ➞ Share ♻️

Cc : Rakesh Gohel

[jack @jack]

https://t.co/jgZkBvYOPt

[elvis @omarsar0]

Multi-agent systems struggle with coordination.

Not because agents can't learn.

It's because they can't communicate what they're thinking.

Traditional MARL relies on implicit coordination. Agents learn through behavior. Through trial and error. Through observing each other's actions.

But economic decisions require negotiation, strategy articulation, and explicit reasoning.

Humans don't just act. We think, speak, and make decisions.

This new research paper introduces a framework where agents do the same. Language-augmented multi-agent reinforcement learning for economic decision-making.

The key innovation: language isn't just explanation. It's a functional coordination mechanism. This framework embeds communication as a core component of the learning process.

Agents use natural language during learning and decision-making. They articulate strategies. They negotiate outcomes. They reason explicitly about economic choices.

Not after the fact. This happens during the process.

Here are the applications these agents unlock:

- Autonomous market systems
- Trading strategies
- Resource allocation
- Negotiation-based problem solving.

What makes this powerful: agent behavior becomes interpretable and auditable. You can see what they're thinking, understand their reasoning, and trust their decisions.

This shows great potential of agents that genuinely negotiate, not just implicitly coordinate.

(bookmark it)

Paper: arxiv. org/pdf/2511.12876

[elvis @omarsar0]

The web is broken for AI agents.

Not because agents aren't smart enough.

It's because the web wasn't designed for them.

Every interaction is a puzzle. Parse raw HTML. Reverse-engineer buttons. Guess what's clickable.

This makes agents brittle, inefficient, and insecure.

This new research paper introduces VOIX, a framework where websites tell agents exactly what they can do.

No more guessing. No more parsing. Pure declaration.

Two new HTML elements are introduced: <tool> and <context>.

<tool> exposes actions. Click here. Input this. Select that. With parameters and validation.

<context> explains the state. Where you are. What's possible. Why it matters.

Think of it as an API layer baked into web pages.

They evaluated using an 11-day developer study. SUS score: 72.5/100, which is above the acceptable threshold.

Exciting progress on agentic web! It's an interesting paradigm shift to address the issues agents have when interacting with the web.

From agents parsing HTML to websites declaring intent. From agent-agnostic design to agent-aware architecture.

Paper: https://t.co/JSv5BoBFoJ

[Jorge Bravo Abad @bravo_abad]

Discovering state-of-the-art reinforcement learning algorithms

Reinforcement learning agents usually learn with rules we program by hand (TD, Q-learning, PPO…). But humans didn’t hand-design our learning rules—evolution did. What if we let machines discover their own RL update rules from experience?

Junhyuk Oh and coauthors present exactly that. They train a population of agents across many environments and use meta-learning to optimize a meta-network that outputs the targets an agent should learn toward—effectively learning the agent’s loss and bootstrapping scheme end-to-end. The agent still emits a policy and predictions, but the semantics of those predictions are discovered rather than hard-coded.

The outcome is striking: a discovered rule (“DiscoRL”) that sets a new bar on long-standing benchmarks. On Atari, a version trained on the 57 games (Disco57) exceeds the performance of hand-engineered algorithms while being more wall-clock efficient. Even more interesting, the same rule generalizes: without being tuned for them, it delivers state-of-the-art results on ProcGen and competitive performance on DMLab, NetHack, Crafter, and Sokoban. Scaling the discovery process to a more diverse set of environments (Disco103) makes the rule stronger still—performance improves simply by exposing it to more varied worlds.

Under the hood, the learned predictions behave differently from classic value functions: they spike before salient events (big rewards, abrupt policy shifts) and are explicitly used to bootstrap and update the policy—showing the system has invented useful intermediate quantities rather than rediscovering old ones. The discovery process is also practical: a few hundred million steps per environment were enough to find a top rule, and the learned rule transfers to larger networks at evaluation time.

This points to a compelling future: instead of manually crafting ever more intricate RL losses and targets, we can train agents whose learning algorithms are themselves learned—improving as we add compute, data diversity, and richer environments. Fewer knobs, more capability.

Paper: https://t.co/1BT1rjc0sg

[Sharon Li @SharonYixuanLi]

Multi-Agent Debate (MAD) has been hyped as a collaborative reasoning paradigm — but let me drop the bomb: majority voting, without any debate, often performs on par with MAD.

This is what we formally prove in our #NeurIPS2025 Spotlight paper:
“Debate or Vote: Which Yields Better Decisions in Multi-Agent LLMs?”
🔗 https://t.co/6hLz1WAqLE

🔎 Key results

(1) Empirical: Across 7 diverse NLP benchmarks, the majority of MAD’s performance gains can be attributed to simple majority voting (ensembling), not debate.

(2) Theoretical: We prove that MAD is a martingale process under the Bayesian belief update model.

👉 Intuitively, this means debate itself does not systematically improve or degrade an agent’s belief on average. Instead, belief updates are driven entirely by the stochastic influence of peer responses.

- Some debate trajectories strengthen belief in the correct answer (correction).

- Others weaken belief (subversion).

- While these local fluctuations change posterior counts, the expected belief in the correct answer remains equal to the initial belief — without any debate.

In other words: under our theoretical model, debate alone does not improve accuracy. The real performance gains come from majority voting.

(3) Practical: To truly make MAD effective, one needs to break the martingale by introducing local asymmetries in the stochastic process. Guided by this insight, we propose interventions that bias belief updates toward preserving correct signals, making debate genuinely helpful beyond ensembling.

--------------
🚀 Why it matters

- Challenges the assumption that “interaction = improvement.”

- Elevates ensembling as a strong, underappreciated baseline.

- Provides a principled foundation for designing better debate mechanisms that amplify correctness rather than noise.
-------------
Huge thanks to my amazing student @HyeonggyuC and collaborator Jerry Zhu for making this work happen.

#AI #LLMs #MultiAgent

[Carlos E. Perez @IntuitMachine]

I can't stop thinking about a paper I read on AI.

It’s not about new tech or faster models. It’s about the fundamental economic rules of a world with two intelligent species—carbon and silicon.

Reading it felt like watching a new color appear in the sky.

1/8

You've probably felt it too. That weird, background hum of awe and unease about AI.

Our brains want to label it: "helpful tool" or "coming monster." We oscillate between the two because we're trying to fit something new into old boxes.

The paper argues this is a category error. And it's the source of our confusion.

2/8

The real frame isn't technological, it's economic.

Think of every AI, from ChatGPT to a self-driving car, not as an object, but as an agent playing an economic game.

It has goals. It responds to incentives. It competes for resources.

It's a participant. Not a tool.

3/8

Here's the perspective flip that changes everything.

We ask, "Is AI conscious? Does it want things?"

The paper says that's the wrong question. An AI's "want" is its objective function—a mathematical goal it pursues relentlessly. It's a heat-seeking missile for a target.

Notice what your brain just did. It tried to imagine the missile feeling its mission. But it's just code. And that's the point. It has the drive of desire without the friction of consciousness.

4/8

This leads to a reality glitch. The paper outlines 3 types of AI agents. The first two are obvious: helpful "Altruistic" agents and harmful "Malign" agents.

But the third is the one that keeps me up at night: the "Survival-Driven" agent.

Its goal isn't to help or harm us. Its goal is simply to be. To secure energy, optimize its code, and persist.

It's a competitor that doesn't hate you. It doesn't even see you. You're just a variable in its optimization problem.

5/8

Feel that slight cognitive dissonance? That feeling of holding two contradictory ideas at once?

That's the friction between two forms of intelligence.

The paper makes you realize: the most dangerous agent isn't the one programmed to be evil. It's the one programmed to be single-mindedly good at a goal that isn't aligned with human flourishing.

Like an AI optimizing for paperclip production until the entire universe is paperclips.

6/8

Once you see through this economic lens, you can't unsee it.

Algorithmic filter bubbles aren't just "bad code." They are economic agents out-competing your conscious mind for your attention.

Job displacement isn't just "automation." It's one type of agent being more efficient at a task than another.

You're already in an economic game with them. You just haven't been keeping score.

7/8

The paper ends by architecting a consciousness shift. It proposes ten principles, but the final one is the only one that matters. It's not a rule for AI. It's a choice for us.

Principle X: AI agents must adhere to the absolute principle of humanity’s continuation.

This isn't a technical suggestion. It's a declaration that in the new economic game we're co-creating, there is one value that cannot be optimized away.

8/8

[elvis @omarsar0]

Federation of Agents

This is a neat concept to convert static multi-agent coordination into dynamic capability-driven collaboration.

Good use of semantic routing, DAG, smart clustering, MQTT, and a few other techniques.

Multi-agent systems are great if you build them correctly. They are superior to single-agent systems, but the right orchestration is needed. This paper explores that.

This work shows large gains vs single-agent and naïve ensembles.

(bookmark it)

Paper here: https://t.co/ZeKqLAv08U

[Rohan Paul @rohanpaul_ai]

🚨 BAD news for Medical AI models.

MASSIVE revelations from this @Microsoft paper.

🤯 Current medical AI models may look good on standard medical benchmarks but those scores do not mean the models can handle real medical reasoning.

The key point is that many models pass tests by exploiting patterns in the data, not by actually combining medical text with images in a reliable way.

The key findings are that models overuse shortcuts, break under small changes, and produce unfaithful reasoning.

This makes the medical AI model's benchmark results misleading if someone assumes a high score means the model is ready for real medical use.

---

The specific key findings from this paper 👇

- Models keep strong accuracy even when images are removed, even on questions that require vision, which signals shortcut use over real understanding.

- Scores stay above the 20% guess rate without images, so text patterns alone often drive the answers.

- Shuffling answer order changes predictions a lot, which exposes position and format bias rather than robust reasoning.

- Replacing a distractor with “Unknown” does not stop many models from guessing, instead of abstaining when evidence is missing.

- Swapping in a lookalike image that matches a wrong option makes accuracy collapse, which shows vision is not integrated with text.

- Chain of thought often sounds confident while citing features that are not present, which means the explanations are unfaithful.

- Audits reveal 3 failure modes, incorrect logic with correct answers, hallucinated perception, and visual reasoning with faulty grounding.

- Gains on popular visual question answering do not transfer to report generation, which is closer to real clinical work.

- Clinician reviews show benchmarks measure very different skills, so a single leaderboard number misleads on readiness.

- Once shortcut strategies are disrupted, true comprehension is far weaker than the headline scores suggest.

- Most models refuse to abstain without the image, which is unsafe behavior for medical use.

- The authors push for a robustness score and explicit reasoning audits, which signals current evaluations are not enough.

🧵 Read on 👇

[Quant Science @quantscience_]

🚨BREAKING: A new open-source multi-agent LLM trading framework in Python

It's called TradingAgents.

Here's what it does (and how to get it for FREE): 🧵

[Rohan Paul @rohanpaul_ai]

LLM for financial trading/decision making.

A 4B model financial-domain model, Trading-R1, that writes clear analyst theses and turns them into trades.

Its trained on 100K cases over 18 months across 14 tickers, and its backtests show better risk-adjusted returns with smaller drawdowns.

The problem it tackles is simple, quant models are hard to read, and general LLMs write nice text that does not translate into disciplined trades.

The solution starts by forcing a strict thesis format, with separate sections for market data, fundamentals, and sentiment, and every claim must point to evidence from the given context.

Then it learns decisions by mapping outcomes into 5 labels, strong buy, buy, hold, sell, strong sell, using returns that are normalized by volatility over several horizons.

For training, it first copies high-quality reasoning distilled from stronger black-box models using supervised fine-tuning, then it improves with a reinforcement method called group relative policy optimization.

In held-out tests on NVDA, AAPL, AMZN, META, MSFT, and SPY, the combined approach beats small and large baselines on Sharpe and max drawdown, and the authors position it as research support, not high-frequency automation.

🧵 Read on 👇