Weather: hellish heat · Lunch: onigiri · Dinner: sushi
Again I only went in the afternoon. I have a good reason: I ran benchmarks until evening, into the small hours in fact, because I’m finally getting results. I’ve come back from the near-tears state of the past weeks — at last I’ll have usable results. Kato’s lab gives me a great many chances to recover, scientifically speaking. That’s partly why there hasn’t been a longer post lately: writing about how I wait for individual results to finish running isn’t exactly riveting.
But I do have a longer look back — not so much about the day as about the last two weeks.
Two Weeks Inside HyMeKo: What Structure Gives Learning and Control
Over the past two weeks the HyMeKo framework moved forward on several fronts at once — learning on signed graphs, closed-form geometric models, a new manipulation benchmark, and a reward loop that bridges the distance between a plain-language success criterion and a reinforcement-learning signal. The threads look independent at first, until you notice they all press on the same question in different clothes: when does explicit structure pay off, and when is it just decoration? Here’s where things stand. I’ll keep the story and the results; the recipes stay in the lab.
Signed graphs: a win where the structure is real
Signed networks — graphs whose edges carry a positive or negative sign — are a clean stress test for structure-aware learning, because the sign pattern encodes global constraints (who trusts whom, and whether those trust relations are mutually consistent) that a naive model simply doesn’t see.
On the established, public signed-network benchmarks, our signed learner scored a clean win on Epinions against the strongest 2025 signed graph transformer, by a considerable margin, and stayed competitive on Slashdot. These are among the harder, larger signed benchmarks in the literature, and the gap measured on Epinions was not subtle. The lesson isn’t a leaderboard trophy; it’s evidence that the model exploits the consistency structure of the sign pattern rather than memorizing edge statistics.
A second, more geometric line — a closed-form learning engine that uses no gradient-based training at all — was validated on the same public network family (Bitcoin-Alpha, Slashdot, Epinions). Backed by a consistency-aware mechanism, it improved predictive quality on all of them, and the relative gain was strongest on the largest network. The interesting part isn’t only accuracy: because the model is closed-form, it comes with latency and memory behavior that gradient-trained models don’t — which we characterized in a sweep as well. The full system is still maturing, but the mechanism itself now rests on solid empirical ground.
A benchmark you can’t game
The most durable new tool of the two weeks is a manipulation benchmark we built as a ladder of falsifiable gates. The motivation came from a recurring annoyance: most “structure helps” claims quietly rely on the flat observation already containing the answer, so the complicated model wins for the wrong reason.
This benchmark is designed so that can’t happen. The first gates establish, provably, that the task is inherently ambiguous from passive observation — a model seeing the raw state performs at chance — and that the hidden property becomes recoverable only through a deliberate, reversible interaction. Then, and only then, may a learned estimator enter the ring: and it recovers the hidden mechanical property from partial, noisy information almost as well as a model handed the true value directly, with the estimate degrading gracefully as the observation gets noisier. Reinforcement learning is deliberately held back until the perception problem has first been solved provably.
This ordering — prove that structure is necessary, prove that it’s recoverable, and only then attempt control — is the point itself. It turns “structure-aware control is better” from a slogan into something falsifiable.
Closing the loop from a plain-language spec to a reward
A quieter result, yet more exciting to me: we closed the loop from a declarative success specification to a working reinforcement-learning reward. A language model essentially proposes what success looks like; the framework calibrates and prunes that description into a usable criterion; and the criterion becomes good enough to rank successful and unsuccessful behavior with high accuracy — far better than the raw, uncalibrated version.
Two weeks ago it stopped here. Now it goes further: the same calibrated specification, now used as the reward driving the learning, ignited a policy about as reliably as the hand-designed dense reward that ships with the task — while the raw, uncalibrated version doesn’t even get going. So a machine-arbitrated, plain-language success criterion is not merely a classifier; it’s a usable training signal. For anyone who has ever spent days hand-shaping reward functions, this is a notable direction.
Reinforcement learning: the abstraction decides
Running through all the control work — a cooperative two-finger manipulation scenario, a pick-and-place task, several MetaWorld tasks — is a lesson that proved itself again and again, and it’s the sentence I’d send a reader off with:
The abstraction you hand the algorithm decides the outcome far more than the algorithm itself.
Whenever reinforcement learning appeared to “fail,” the failure traced back to a bad action representation, a gap between the coverage of the demonstrations and the situations the policy actually experiences, or a measurement artifact — never to reinforcement learning being fundamentally incapable of the task. Give the same problem a structured or command-level action space, and it succeeds; give it a raw, step-by-step action space, and it’s essentially bottomless. In the pick-and-place work we chased a residual-learning approach to its honest conclusion and found that the real bottleneck was somewhere else entirely: not in the reinforcement step, but in the quality of the behavior it was built on. Knowing which term actually constrains you is most of the battle — and in this area much of the wasted compute comes from optimizing the wrong term.
We also ran a reward-auditing-and-repair pass on a manipulation task and cut the impact of a misleading proxy signal by well over an order of magnitude, realigning the reward to what the task’s monitors actually care about. Same theme: the reward is structure too, and getting it right matters more than the optimizer.
Why they belong together
None of this is really about signed graphs or benchmarks or rewards separately. HyMeKo is organized around a single idea — that the same explicit, checkable structure should flow through perception, learning, and control — and the two weeks were a series of tests of where that pays off:
- On signed graphs, structure pays off where the constraints are global and real, and that’s exactly where the gains were largest.
- On the manipulation benchmark, structure is provably necessary, so a structure-aware estimator wins by construction — and we made “necessary” a falsifiable claim, not an assumption.
- In reward design, a machine-arbitrated specification proves to be a legitimate training signal, not merely an evaluation metric.
- In control, the representation is the lever; the algorithm is almost a spectator.
What comes next: taking the geometric signed-graph engine from a validated mechanism to a full model, extending the benchmark ladder to the control gates, and carrying the spec-to-reward loop to a broader set of tasks. There’s a signed-graph angle on mapping and navigation too, which I think is genuinely new — but I’ll save that for when there are numbers behind it.
If you work on structure-aware learning or robotic manipulation and would enjoy comparing notes, I’d be glad to talk. The details — architectures, training setups, and the benchmark internals — are being prepared for peer review, so this post stays at the level of what we found, not how to rebuild it.