Harjinder Singh

[Dan Martland @DanTVusa]

⚡️ Just madness ⚡️
Did you catch tonight’s storm?
#Lightning #NewYorkCity #Rainbow

[Amazon Web Services @awscloud]

More AI-generated code doesn't make your team faster. It might actually slow you down.

[Harjinder Singh @pisingh_]

Views from the suburb.

[Harjinder Singh @pisingh_]

The suburb.

[New York Post @nypost]

NYC rents keep surging to all-time highs - but a suburb right across the Hudson is getting much cheaper: Study https://t.co/bRWcKX0qXV

[Harjinder Singh @pisingh_]

$29 mn Yacht parked in the suburb. #TheMaverick

[Tuomas Artman @artman]

Today is a hard day. I shared this note with the @linear team today: We’ve made the difficult decision to increase our workforce. This is not a cost-cutting exercise or a reflection of anyone’s performance. We’re simply reimagining every role for the agentic AI era. We’re hiring. We’re sorry about that.

[Harjinder Singh @pisingh_]

More bullish!

[Harjinder Singh @pisingh_]

Optimistic on AWS's Agentic AI future.

[Cathryn @cathrynlavery]

your terminal in 4 upgrades:

1. ghostty — the terminal itself. fast, native, beautiful. finally one worth using.

2. tmux — sessions that survive anything. split panes, detach, come back later like nothing happened.

3. fish — autocomplete that actually works. syntax highlighting. no config needed.

4. starship — a prompt that shows you what matters (git branch, exit codes, env) without slowing you down.

use: brew install tmux fish starship + ghostty .org

your future self will thank you

[Harjinder Singh @pisingh_]

Will Claude launch a world class stock trading app next and crash the hedge fund market?

[Victor Mota @vimota]

https://t.co/ZawLeEowwu

[DAIR.AI @dair_ai]

Can a single agent with skills replace multi-agent systems?

Multi-agent systems work well for complex reasoning where specialized agents collaborate through explicit communication.

But this incurs substantial computational overhead in tokens and latency.

This new research explores whether you can compile a multi-agent system into an equivalent single-agent system by trading inter-agent communication for skill selection.

The answer: yes, but with a caveat.

Preliminary experiments show single-agent approaches with skill libraries can substantially reduce token usage and latency while maintaining competitive accuracy on reasoning benchmarks.

So far, so good.

But here's where it gets interesting. The researchers asked: How does skill selection scale as libraries grow?

Drawing on cognitive science, they propose that LLM skill selection exhibits bounded capacity analogous to human decision-making. And they found an interesting pattern.

Rather than degrading gradually, selection accuracy remains stable up to a critical library size, then drops sharply. But it looks like a phase transition, not a smooth decline. This mirrors capacity limits observed in human cognition.

The culprit isn't library size alone. It's the semantic confusability among similar skills. When skills are too semantically similar, the model can't reliably distinguish between them.

This suggests hierarchical organization, which has long helped humans manage complex choices, may similarly benefit AI systems. Initial results with hierarchical routing support this hypothesis.

As we build increasingly capable agents with expanding skill sets, understanding these fundamental limits becomes critical. You can't just keep adding skills indefinitely. There's a threshold where selection breaks down, and it happens suddenly, not gradually.

Paper: https://t.co/3RMAu3Fcnp

Learn to build effective AI agents in our academy: https://t.co/zQXQt0PMbG

[Harjinder Singh @pisingh_]

@michelleefang Vibe coding something exciting about frontier models

[elvis @omarsar0]

The next scaling frontier isn't bigger models.

It's societies of models and tools.

That's the big claim made in this concept paper.

It actually points to something really important in the AI field.

Let's take a look:

(bookmark for later)

Classical scaling laws relate performance to parameters, tokens, and compute. More of each, better loss. These laws have driven a decade of progress. But they describe a single-agent world: one model, static corpus, one prompt at a time.

There is a clear misalignment with how real-world problems actually work.

This new perspective paper argues that scaling must expand along three new axes: population, organization, and institution. Not just how many parameters, but how many agents, how they're connected, and what norms govern their interaction.

Simply adding more agents doesn't monotonically improve performance.

Early experiments in multi-agent debate show that naive agent swarms can degenerate into majority herding, where the first plausible-but-wrong answer locks in and gets reinforced through subsequent rounds. Groups of frontier models fail to integrate distributed information, displaying human-like collective failures.

The paper proposes three interaction regimes for multi-agent systems:

1) Competition: debate, adversarial critique, self-play.

2) Collaboration: role specialization, division of labor, complementary expertise.

3) Coordination: orchestrated workflows, planner-worker hierarchies, reliable execution.

Which regime fits which task matters. Competitive regimes suit focused reasoning problems with clear correctness criteria. Collaborative regimes fit an open-ended design where diverse skills are needed. Coordinated regimes handle long-horizon, safety-critical workflows.

The architectural implications are significant. Effective multi-agent systems need cognitive diversity: agents with different priors, reasoning styles, and tool access. They need institutional memory: persistent artifacts that outlive individual sessions, analogous to lab notebooks and version control. They need communication topologies: not just broadcast or hub-and-spoke, but structured graphs that balance diversity and coherence.

Training objectives must change, too. Current models optimize individual next-token prediction. Multi-agent systems need collective objectives: group accuracy, calibration, hypothesis diversity, and conflict resolution quality. The paper proposes "multi-agent pretraining" where debate, peer review, and negotiation become first-class optimization targets.

Paper: https://t.co/OqwIIeJe8T

Learn to build AI agents in my academy: https://t.co/JBU5beHQNs

[Amazon Web Services @awscloud]

Building production-ready AI agents just got easier with Amazon Bedrock AgentCore MCP server

Deploying agents used to require handling complex configurations yourself.

Now you can complete these tasks in just minutes by chatting with your coding assistant!

The demo shows integrating AgentCore into a weather app using Kiro as the coding assistant, but you can use any MCP enabled AI coding tool.

Within minutes, you'll have a fully-loaded application with memory capabilities, ready for production deployment on AWS.

[Sumanth @Sumanth_077]

Agent Memory That Works Like Human Memory!

Hindsight is an agent memory system built to create smarter agents that actually learn over time.

Here's the biggest problem:

Existing open-source memory solutions rely heavily on RAG, vector databases, and knowledge graphs. These are great for searching for context, but they do not facilitate deep learning from past experiences.

Vectorize solves this with a fundamentally different approach, building a system that mirrors how humans form and strengthen long-term memory.

Here's the Key Architectural Difference:

Hindsight uses two core techniques to mimic human memory structure:

• TEMPR (Temporal Entity Memory Priming Retrieval): A mechanism focused on context-aware memory recall.
• CARA (Coherent Adaptive Reasoning Agents): A method dedicated to agent-specific reflection and reasoning over past actions.

When new information enters the system, Hindsight deconstructs it into multiple representations: time series, entity-relationship, semantic, and keyword structures.

This enables the system to retrieve the most relevant memories in the most efficient way possible.

Hindsight is the first system to surpass 90% accuracy on LongMemEval, the industry standard benchmark for evaluating long-term memory in AI systems, achieving a score of 91.4%.

It's 100% Open Source.

Link to the Github Repo in the comments!

[Rachit Bansal @rach_it_]

Current LLMs support contexts with millions of tokens. However, we keep seeing failure modes due to poor long-context reasoning.

Our new work shows that, for long contexts, we must perform test-time training updates rather than vanilla ICL or “thinking”!

w/ @Meta & @KempnerInst

[Muratcan Koylan @muratcan]

Since Manus is trending again, it's a good time to revisit their blog on context engineering & multi-agent systems.

One of the reasons many people choose their agent instead of ChatGPT or others is that the Wide Research agent can run for a very long time, create tables or docs for you, and frankly, it's so far the best computer use agent.

Deep researching multiple entities is more of a context problem than a planning problem. By item 8-9 in any multi-subject research task, LLMs start making things up. Not simplifying. Fabricating.

- Items at the beginning and end get recalled; middle items get forgotten.
- 400K tokens isn't 2x the cost of 200K. It's disproportionately more expensive in time and compute.
- Models trained on chatbot-style interactions feel "impatient" when assistant messages get long. They rush to summarize, shift to bullet points, start cutting.

This is why we should separate what we store from what the model sees. Your session holds everything. The working context is a filtered, compressed snapshot built fresh for each call.

Manus's solution: parallel sub-agents with fresh context. Instead of one processor handling n items sequentially, they deploy n sub-agents processing n items simultaneously.

With this "context isolation," sub-agents don't communicate with each other; all coordination flows through the main controller.

This prevents context pollution. An error in one sub-agent doesn't propagate to others.

Their full context engineering blog goes deeper on principles that apply beyond Wide Research:
- Manus constantly rewrites a todo md file during tasks. This pushes the global plan into recent attention span, counteracting "lost in the middle" decay.
- File system as memory. Treat files as externalized context; unlimited, persistent, and operable by the agent. Compression should always be restorable. A URL can replace page content; a path can replace document contents.
- Keep errors visible. Don't hide failed actions. Leaving wrong turns in context helps the model avoid repeating mistakes. Error recovery is underrated in benchmarks but critical in production.

Decompose. Parallelize. Synthesize.

[elvis @omarsar0]

This is a fascinating paper.

It's well known that long-horizon agents have a memory problem.

The standard approach is to append everything to the context. Every past observation, action, and thought gets added to the prompt.

This creates three compounding issues: O(N) memory growth, degraded reasoning on out-of-distribution context lengths, and attention dilution that causes the model to forget key details even when they're technically in the prompt.

This new research unifies memory and reasoning into a single process.

It introduces MEM1, an RL framework that trains agents to maintain constant memory across arbitrarily long multi-turn tasks.

At each turn, the model updates a compact internal state that simultaneously consolidates prior information and reasons about next actions. After each turn, all previous observations, actions, and states are discarded. Only the most recent internal state remains.

Inference-time reasoning serves two purposes. While reasoning about the current query, the model also extracts and stores exactly what it needs for future turns. Memory consolidation becomes part of the reasoning process itself, not a separate module.

Training uses PPO with a masked trajectory technique. Because MEM1 dynamically prunes context, standard policy optimization breaks since tokens don't belong to a single continuous trajectory. The authors solve this by stitching sub-trajectories together and applying 2D attention masks that restrict each token's attention to only what was visible when it was generated.

The results show dramatic efficiency gains:

On 16-objective multi-hop QA, MEM1-7B improves performance by 3.5x while reducing memory usage by 3.7x compared to Qwen2.5-14B-Instruct. Peak token usage stays nearly constant as task complexity increases, while baseline methods scale linearly. On WebShop navigation, MEM1-7B outperforms AgentLM-13B (twice the parameters) with 2.8x less peak token usage.

Notably, the agent trained on 2-objective tasks generalizes to 16-objective tasks. Performance actually improves relative to baselines as horizon length increases, because baseline models degrade on out-of-distribution context lengths while MEM1 maintains constant context.

Emergent behaviors appear in the trained agents: maintaining structured memory for multiple concurrent questions, shifting focus when one objective stalls, and interleaving reasoning with selective memory updates.

External memory modules require separate training and engineering overhead. Full-context approaches don't scale. MEM1 shows that end-to-end RL can train models to consolidate memory as part of reasoning, achieving both efficiency and performance without architectural changes.

Paper: https://t.co/q9pEIxBpit

Learn to build effective AI Agents in my academy: https://t.co/JBU5beIoD0

[Muratcan Koylan @muratcan]

Cursor published a post last week arguing the cost of CMS abstractions is now higher than the cost of just editing code with agents.

I ran the same experiment on our website and cut WordPress, shipped the marketing site and resources as raw code.

The site is now static HTML/JS. No server app, no database, no CMS API in the request path.

There's an admin UI for drafting and exporting JSON, but publishing is git-first.

Why this matters: agents work best when content is grep-able.

- "Add a new section to the homepage" is one prompt.
- "Fix broken links across all posts" is one prompt.
- "Rename the resources taxonomy" is one prompt.

Those same tasks in WordPress are very mundane through the admin panel, plugins, and database tables.

It took ~0.5 day to get a working static site + resources + admin UI. I used Opus 4.5 in Cursor. It migrated the posts, generated routing, and built the admin UI in one session.

If your team can live in git, you probably don't need a CMS or any no-code website builders anymore.