frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

Open in hackernews

HyperAgents: Self-referential self-improving agents

https://github.com/facebookresearch/hyperagents
51•andyg_blog•2d ago
https://arxiv.org/abs/2603.19461

Comments

flockonus•1h ago
The readme seems very unclear about what it does. Anyone has a practical example of it?
pegasus•1h ago
There's a paper at https://arxiv.org/abs/2603.19461

Abstract:

Self-improving AI systems aim to reduce reliance on human engineering by learning to improve their own learning and problem-solving processes. Existing approaches to self-improvement rely on fixed, handcrafted meta-level mechanisms, fundamentally limiting how fast such systems can improve. The Darwin Gödel Machine (DGM) demonstrates open-ended self-improvement in coding by repeatedly generating and evaluating self-modified variants. Because both evaluation and self-modification are coding tasks, gains in coding ability can translate into gains in self-improvement ability. However, this alignment does not generally hold beyond coding domains. We introduce \textbf{hyperagents}, self-referential agents that integrate a task agent (which solves the target task) and a meta agent (which modifies itself and the task agent) into a single editable program. Crucially, the meta-level modification procedure is itself editable, enabling metacognitive self-modification, improving not only the task-solving behavior, but also the mechanism that generates future improvements. We instantiate this framework by extending DGM to create DGM-Hyperagents (DGM-H), eliminating the assumption of domain-specific alignment between task performance and self-modification skill to potentially support self-accelerating progress on any computable task. Across diverse domains, the DGM-H improves performance over time and outperforms baselines without self-improvement or open-ended exploration, as well as prior self-improving systems. Furthermore, the DGM-H improves the process by which it generates new agents (e.g., persistent memory, performance tracking), and these meta-level improvements transfer across domains and accumulate across runs. DGM-Hyperagents offer a glimpse of open-ended AI systems that do not merely search for better solutions, but continually improve their search for how to improve.

functional_dev•49m ago
This 'self vs non-self' logic is very similar to how plants prevent self-pollination. They have a biological 'discrimination' system to recognize and reject their own genetic code.

Here is a breakdown - https://vectree.io/c/plant-self-incompatibility-logic

OutThisLife•1h ago
Hermes agent does this, if you're curious

https://github.com/NousResearch/hermes-agent

jauntywundrkind•1h ago
Pi is self modifying, self aware. https://lucumr.pocoo.org/2026/1/31/pi/

But this idea of having a task agent & meta agent maybe has wings. Neat submission.

ghywertelling•1h ago
What are the differences wrt Recursive Language Models
Jerrrrrrrry•1h ago
No matter how far we go, we end up with generation / discrimination architecture.

Its is the core of any and all learning/exellency; exposure to chaotic perturbations allow selection of solutions that are then generalized to further, ever more straining problems; producing increasingly applicable solutions.

This is the core of evolution, and is actually derivable from just a single rule.

ilaksh•1h ago
It's a feedback loop.

I've always felt that the most important part of engineering was feedback loops.

Maybe nature is the greatest engineer ever?

NitpickLawyer•1h ago
The paper is here - https://arxiv.org/pdf/2603.19461

This, IMO is the biggest insight into where we're at and where we're going:

> Because both evaluation and self-modification are coding tasks, gains in coding ability can translate into gains in self-improvement ability.

There's a thing that I've noticed early into LLMs: once they unlock one capability, you can use that capability to compose stuff and improve on other, related or not, capabilities. For example "reflexion" goes into coding - hey, this didn't work, let me try ... Then "tools". Then "reflxion" + "tools". And so on.

You can get workflows that have individual parts that aren't so precise become better by composing them, and letting one component influence the other. Like e2e coding gets better by checking with "gof" tools (linters, compilers, etc). Then it gets even better by adding a coding review stage. Then it gets even better by adding a static analysis phase.

Now we're seeing this all converge on "self improving" by combining "improving" components. And so on. This is really cool.

binarymax•1h ago
I disagree that evaluation is always a coding task. Evaluation is scrutiny for the person who wants the thing. It’s subjective. So, unless you’re evaluating something purely objective, such as an algorithm, I don’t see how a self contained, self “improving “ agent accomplishes the subjectivity constraint - as by design you are leaving out the subject.
ranyume•42m ago
In science there are ways to surface subjectivity (cannot be counted) into observable quantized phenomena. Take opinion polls for instance: "approval" of a political figure can mean many things and is subjective, but experts in the field make "approval" into a number through scientific methods. These methods are just an approximation and have many IFs, they're not perfect (and for presidential campaign analysis in particular they've been failing for reasons I won't clarify here), but they're useful nonetheless.

Another thing that get quantized is video preferences to maximize engagement.

sharkjacobs•41m ago
> unless you’re evaluating something purely objective, such as an algorithm

Or maybe some kind of really simple task like manufacturing paperclips

lukebuehler•35m ago
Agree. It's code all the way down. The key is to give agents a substrate where they can code up new capabilities and then compose them meaningfully and safely.

Larger composition, though, starts to run into typical software design problems, like dependency graphs, shared state, how to upgrade, etc.

I've been working on this front for over two years now too: https://github.com/smartcomputer-ai/agent-os/

testaccount28•25m ago
because submarine piloting is a going-under-water activity, improvements in holding one's breath can lead to faster submersibles.
llmslave•1h ago
I think even code bases will have self improving agents. Software is moving from just the product code, to the agent code that maintains the product. Engineering teams/companies that move in this direction will vastly out produce others.

I've had to really shift how I think about building code bases, alot of logic can go into claude skills and sub agents. Requires essentially relearning software engineering

sonu27•36m ago
Can someone add this to OpenClaw :)
measurablefunc•29m ago
That's great but how about UltraAgents: Meta-referential meta-improving self-referential hyperagents?

Why so many control rooms were seafoam green (2025)

https://bethmathews.substack.com/p/why-so-many-control-rooms-were-seafoam
241•Amorymeltzer•1d ago•42 comments

My minute-by-minute response to the LiteLLM malware attack

https://futuresearch.ai/blog/litellm-attack-transcript/
178•Fibonar•3h ago•84 comments

Doom entirely from DNS records

https://github.com/resumex/doom-over-dns
76•Venn1•3d ago•21 comments

Colibri – chat platform built on the AT Protocol for communities big and small

https://colibri.social/
57•todotask2•2h ago•22 comments

Moving from GitHub to Codeberg, for lazy people

https://unterwaditzer.net/2025/codeberg.html
407•jslakro•5h ago•202 comments

HyperAgents: Self-referential self-improving agents

https://github.com/facebookresearch/hyperagents
51•andyg_blog•2d ago•20 comments

OpenTelemetry profiles enters public alpha

https://opentelemetry.io/blog/2026/profiles-alpha/
84•tanelpoder•3h ago•9 comments

Personal Encyclopedias

https://whoami.wiki/blog/personal-encyclopedias
725•jrmyphlmn•23h ago•147 comments

Fermented foods shaped human biology

https://press.asimov.com/articles/culture-shift
22•mailyk•6d ago•13 comments

Stripe Projects: Provision and manage services from the CLI

https://projects.dev/
54•piinbinary•3h ago•13 comments

Show HN: Turbolite – a SQLite VFS serving sub-250ms cold JOIN queries from S3

https://github.com/russellromney/turbolite
8•russellthehippo•37m ago•1 comments

From zero to a RAG system: successes and failures

https://en.andros.dev/blog/aa31d744/from-zero-to-a-rag-system-successes-and-failures/
236•andros•2d ago•72 comments

My home network observes bedtime with OpenBSD and pf

https://ratfactor.com/openbsd/pf-gateway-bedtime
81•ibobev•3d ago•23 comments

Interoperability Can Save the Open Web (2023)

https://spectrum.ieee.org/doctorow-interoperability
147•janandonly•4h ago•43 comments

Running Tesla Model 3's computer on my desk using parts from crashed cars

https://bugs.xdavidhu.me/tesla/2026/03/23/running-tesla-model-3s-computer-on-my-desk-using-parts-...
807•driesdep•22h ago•281 comments

End of "Chat Control": EU parliament stops mass surveillance

https://www.patrick-breyer.de/en/end-of-chat-control-eu-parliament-stops-mass-surveillance-in-vot...
431•amarcheschi•7h ago•223 comments

Taming LLMs: Using Executable Oracles to Prevent Bad Code

https://john.regehr.org/writing/zero_dof_programming.html
7•mad44•1h ago•0 comments

Obsolete Sounds

https://citiesandmemory.com/obsolete-sounds/
183•benbreen•15h ago•35 comments

Building a Blog with Elixir and Phoenix

https://jola.dev/posts/building-a-blog-with-elixir-and-phoenix
35•shintoist•2h ago•2 comments

Light on Glass: Why do you start making a game engine?

https://analogdreamdev.substack.com/p/light-on-glass
29•atan2•3d ago•12 comments

Shell Tricks That Make Life Easier (and Save Your Sanity)

https://blog.hofstede.it/shell-tricks-that-actually-make-life-easier-and-save-your-sanity/
427•zdw•19h ago•206 comments

Swift 6.3

https://www.swift.org/blog/swift-6.3-released/
281•ingve•12h ago•182 comments

Olympic Committee bars transgender athletes from women’s events

https://www.nytimes.com/2026/03/26/world/olympics/ioc-transgender-athletes-ban.html
88•RestlessMind•5h ago•179 comments

Show HN: Orloj – agent infrastructure as code (YAML and GitOps)

https://github.com/OrlojHQ/orloj
8•An0n_Jon•14h ago•5 comments

Ashby (YC W19) Is Hiring Engineers Who Make Product Decisions

https://www.ashbyhq.com/careers?ashby_jid=c3c7125d-7883-4dff-a2bf-f5a55de4a364&utm_source=hn
1•abhikp•12h ago

The Oxford Comma – Why and Why Not

https://www.deborahcourtbooks.com/post/the-oxford-comma-why-and-why-not
6•taubek•2h ago•6 comments

Intel Announces Arc Pro B70 and Arc Pro B65 GPUs

https://www.techpowerup.com/347703/intel-announces-arc-pro-b70-and-arc-pro-b65-gpus-maxes-out-xe2...
118•throwaway270925•5h ago•56 comments

Optimizing a lock-free ring buffer

https://david.alvarezrosa.com/posts/optimizing-a-lock-free-ring-buffer/
73•dalvrosa•2d ago•65 comments

SpaceStarCarz KoolWheelz Paper Models

https://davesdesigns.ca/dcc/html/spacestarcarz_.html
29•exvi•2d ago•4 comments

ARC-AGI-3

https://arcprize.org/arc-agi/3
481•lairv•1d ago•317 comments