Currently doing independent AI safety research and blogging!
In reverse date order, I’ve been a:
Fellow in Astra Fellowship 2.0 with Redwood Research, mentored by Adam Kaufman
I wrote about my work in Untrusted advice for AI control: Short, strong advice significantly uplifts weak LLMs
MATS 8.1 scholar, mentored by Micah Carroll
We wrote the paper Prompt Optimization Makes Misalignment Legible
Software engineer at Google Gemini
Worked part-time with GDM Scalable Alignment on their MONA paper
President of Cornell Effective Altruism
I enjoy tabletop games (as a player or GM), board games, meditation, partner dancing, bouldering, making music, reading (esp. hard sci-fi/fantasy), podcasts, and hanging out with my friends.
The kind of intellectual work I enjoy often involves thinking about systems, working out what they incentivize, and iterating to improve those incentives.
I have not signed any contracts that I can’t mention exist, as of July 25, 2026. I’ll try to update this statement at least once a year, so long as it’s true. I added this statement thanks to the one in the gears to ascension’s bio.
To address your issue where autoresearch runs are hard to parse, my first instinct is to make the autoresearch agent submit instructions for how to implement the solution, rather than submitting a solution directly. Then, a separate agent would use the instructions to implement a solution, which is what gets scored. Since the instructions must be clear and informative enough for the implementer agent to write a successful solution, a human should be able to understand the important parts of the solution just by reading the instructions.
This idea is similar to the untrusted advice protocol I worked on recently, where “advice” is on the level of an entire submission, rather than appearing once per step.
Details:
Even though it won’t submit its solution directly, you can allow the autoresearch agent to perform whatever experiments it wants before writing instructions.
This may make it harder to understand the reason behind these instructions, since a lot of computation and cognition can go into picking the exact strategy, but it’s probably still worth it.
You can limit or penalize the instructions based on their total length or LLM surprisal, which should make them shorter and therefore easier to parse.
The implementer agent could be a less capable model than the autoresearch agent.
Besides being somewhat cheaper and faster, this may force the instructions to be more interpretable. The autoresearch agent can’t depend on its delegate to implement the submission exactly the way it would, so it has to explicitly spell out important design details.
To avoid implementing the same boilerplate over and over, you could let the autoresearch agent instruct the implementer agent to modify a past submission, rather than starting from scratch. To understand a result that comes from a chain of submissions, you could just read the instructions for each submission in order.
If you want to make sure that the final result doesn’t depend on idiosyncratic choices made by the implementer agent at intermediate checkpoints, you could replay the chain of instructions that produced the highest-scoring submission to get a final score (and tell the autoresearch agent that you will do this).
You can delete irrelevant or unexplained details from the instructions, and/or paraphrase the instructions using an LLM. This ensures that every instruction has a clear reason behind it, and that there is no steganography.
For example, instructions to use a certain random seed are very unlikely to be legitimate and should be removed.