It doesn't predict what might work. It builds what does — and proves it.

How it evolves — and self-verifies — a capability

This is the loop of the intelligence itself. It is never told the steps: it proposes, verifies against reality, and evolves — and every proven ability becomes a building block for a deeper one. That is what self-improving means here, concretely.

How it knows why code works — and what to avoid

This is the heart of it, and it is genuinely new. The equations are proprietary; what they do is not a secret.

See it for yourself — two environments, one engine real capture

Exhibit A — a user interface, operated like a human. The engine perceives the live screen and its controls — given no API, no source code, no internals — and operates them (click, type) to reach a goal, exactly as a person would with a mouse and keyboard. It was given none of these steps; the trace is replayed against the live app, and every state change is real.

def coheron(app):
    app.reset()          # observe the software
    # it can click, type, and read state — and nothing else.
    return app.snap()    # it knows NOTHING about this app yet

def coheron(app):
    app.reset()
    app.click('nav_account')
    app.type('user'); app.type('pass'); app.click('do_login')      # signs in
    app.click('nav_catalog'); app.click('add_p1')                  # puts an item in the cart
    app.click('nav_cart'); app.click('go_checkout')                # opens checkout
    app.type('addr_name'); app.type('addr_line'); app.type('addr_city')
    app.click('save_address')                                      # shipping saved
    app.type('card_num'); app.type('card_exp'); app.click('save_payment')
    app.click('place_order')                                       # ORDER PLACED
    return app.snap()['orders'] >= 1

This is one of many. From that same empty seed, with no human writing steps and no training, the engine grew a whole library of verified capabilities — each proven before it was kept, the deeper ones built on the ones before them.

Exhibit B — backend code, written and proven

A completely different environment — no interface at all. Here the same engine composes primitive operations into new functions and keeps one only when it verifies on held-out inputs. Same intelligence, same rule, a different world: it operates software like a human and writes code like an engineer.

sort([3, 1, 2])   →   [1, 2, 3]

def evolved(x):                 # it composed:  neg(times2(sort(x)))
    return [ -2 * v for v in sorted(x) ]
# [3, 1, 2]      → [-2, -4, -6]
# [5, 5, 5]      → [-10, -10, -10]

triple([3, 1, 2])       →   [9, 3, 6]
triple([-2, 0, 4, 7])   →   [-6, 0, 12, 21]

…and it kept going, on its own

Every ability below was grown and verified by the engine from that seed — organized by the generation it appeared in. Nobody specified this list. It set its own goals and discovered what was reachable; the deeper the generation, the more it had to build on itself to get there.

Generation 0 is what it could reach directly; each later generation required chaining abilities it had already built and proven — for example the full field-inspection sign-off (assign → measure → submit → approve → export) only became reachable once the steps beneath it existed. That is growth beyond the starting state, in the open, with no target handed to it.

Why it only gets stronger

It is not a model you train once and freeze. It is a living system — and it compounds.

And it is not one trick — the reach is the point

The same engine has grown and proven capabilities across kinds of software, kinds of interface, kinds of use, and independent environments:

A different road to general intelligence

For anyone tracking where AI goes next: this is open-ended self-improvement with verification built in — the one combination the prediction-based paradigm doesn't have.