Rudybega

I actually think the vocals from ~2:00-~2:35 are pretty impressive there. It's wild to me that the models can play with tempo like that.

I've been listening to this across a variety of genres though, maybe these lyrics and vocals are more to your taste:

(similar to Opeth) https://suno.com/song/9ab8da05-c3f2-412d-80b4-c7d0b3ae840f?s...

(indie rock) https://suno.com/song/756dd139-4cba-4e40-b29c-03ace1c69673

I think AI is starting to verge on making actual good music. The latest Suno release is wild.

An example here: https://v.redd.it/fqlqrgumo5rf1

I find this one interesting because Rap has classically been difficult for these models (I think because it's technically difficult to find the right rhythms and flow for a given set of lyrics).

Sorry, those figures are skewed by Timelord Georg, who has been using AI for 100 million hours a day, is an outlier, and should have been removed.

If we develop a system that can:

- compress (in a relatively recoverable way) the entire domain of human knowledge

- interpolate across the entire domain of human knowledge

- draw connections or conclusions that haven't previously been stated explicitly

- verify or disprove those conclusions or connections

- update its internal model based on that (further expanding the domain it can interpolate within)

Then I think we're cooking with gasoline. I guess the question becomes whether those new conclusions or connections result in a convergent or divergent increase in the number of new conclusions and connections the model can draw (e.g. do we understand better the domains we already know or does updating the model with these new conclusions/connections allow us to expand the scope of knowledge we understand to new domains).

Abstract: "The cycle of scientific discovery is frequently bottlenecked by the slow, manual creation of software to support computational experiments. To address this, we present an AI system that creates expert-level scientific software whose goal is to maximize a quality metric. The system uses a Large Language Model (LLM) and Tree Search (TS) to systematically improve the quality metric and intelligently navigate the large space of possible solutions. The system achieves expert-level results when it explores and integrates complex research ideas from external sources. The effectiveness of tree search is demonstrated across a wide range of benchmarks. In bioinformatics, it discovered 40 novel methods for single-cell data analysis that outperformed the top human-developed methods on a public leaderboard. In epidemiology, it generated 14 models that outperformed the CDC ensemble and all other individual models for forecasting COVID-19 hospitalizations. Our method also produced state-of-the-art software for geospatial analysis, neural activity prediction in zebrafish, time series forecasting and numerical solution of integrals. By devising and implementing novel solutions to diverse tasks, the system represents a significant step towards accelerating scientific progress."

This seems like really cool research and a natural next step for AlphaEvolve style algorithms in a slightly different problem domain.

This is true, but there are methods to greatly reduce the effect of this and generate results that match or even improve overall output accuracy:

e.g. DOMINO https://arxiv.org/html/2403.06988v1

This is what they tell you in driver's education to try and reduce the odds you hit pedestrians, but it's not legally true in most jurisdictions.

This mostly gets avoided with maximum buyin limits on tables. Sure someone can accrue well over that amount, but that's part of cash poker too (dealing with players with large stacks).

Obviously players with much larger bankrolls can weather variance better, but that should even out at pretty much any table a player should reasonably be at (don't play stakes you can't afford where losing the money severely negatively impacts your life).

You are correct. I need some coffee.

I think OpenAI has projected 12.7B in revenue this year and 29.4B in 2026.

Edit: I am dumb, ignore the second half of my post.

It's not really a function of maintaining coherency across context length. It's more about whether the model can accomplish a long time horizon task when the context length of a single message isn't even close to sufficient for keeping track of the all the things that have occurred in pursuit of the task's completion.

Basically, the model has to keep some notes about its overall goals and current progress. Then the context window has to be seeded with the relevant sections from these notes to accomplish sub goals that help with the completion of the overall goal (beat the game).

The interesting part here is whether the models can even do this. A single context window isn't even close to sufficient to store all the things the model has done to drive the next action, so you have to figure out alternate methods and see if the model itself is smart enough to maintain coherency using those methods.

All of that is totally unrelated to the point I'm trying to make.

Pokemon is interesting because it's a test of whether these models can solve long time horizon tasks.

That's it.

Shh, don't worry and just embrace the spiral.

Edit: No spiral emojis allowed, clearly this site will be the first to fall.

He has spoken repeatedly about running for a third term.

The state space for actions in Pokemon is hilariously, unbelievably larger than the state space for chess. Older chess algorithms mostly used Brute Force (things like minimax) and the number of actions needed to determine a reward (winning or losing) was way lower (chess ends in many, many, many fewer moves than Pokemon).

Successfully navigating through Pokemon to accomplish a goal (beating the game) requires a completely different approach, one that much more accurately mirrors the way you navigate and goal set in real world environments. That's why it's an important and interesting test of AI performance.

I mostly use Roo Code inside visual studio. The modes are awesome for managing context length within a discrete unit of work.

I'm going to have to heavily disagree. Gemini 2.5 Pro has super impressive performance on large context problems. I routinely drive it up to 4-500k tokens in my coding agent. It's the only model where that much context produces even remotely useful results.

I think it also crushes most of the benchmarks for long context performance. I believe on MRCR (multi round coreference resolution) it beats pretty much any other model's performance at 128k at 1M tokens (o3 may have changed this).

You could just use something like roo code with custom modes rather than manually injecting them. The orchestrator mode can decide on the other appropriate modes to use for subtasks.

You can customize the system prompts, baseline propmts, and models used for every single mode and have as many or as few as you want.

The context7 mcp works similarly. It allows you to search a massive constantly updated database of relevant documentation for thousands of projects.

This is kind of what the modes in roo code do now. I'm having great success with them and having them as a default just rolled out a couple days ago.

There are a default set of modes (orchestrator, code, architect, debug, and ask) and you can create your own custom ones (or have roo do it for you, which is kind of a fun meta play).

Orchestrator basically consults the others and uses them when appropriate, feeding in a sensible amount of task definition and context into the sub task. You can use different LLMs for different modes as well (I like Gemini 2.5 Pro for most of the thinking style ones and gpt o4-mini for the coding).

I've done some reasonably complicated things and haven't really had an orchestrator task creep past ~400k tokens before I was finished and able to start a new task.

There are some people out there who do really cool stuff with memory banks (basically logging and progress tracking), but I haven't played a ton with that yet.

Basic overview: https://docs.roocode.com/features/boomerang-tasks

Custom Modes: https://docs.roocode.com/features/custom-modes