strujillo

Yeah exactly — that “no LLM in the loop” constraint forces everything to be explicit and verifiable.

I put together a few experiments where the system rediscovers known laws directly from raw data (solar wind, exoplanets, etc).

Happy to share if you’re curious — still very early but interesting to see what emerges.

Exactly — that was the surprising part for me too.

The system has no notion of “physics” at all — it’s just searching for compressible structure in the data.

The fact that GR relations emerge from observables suggests that a lot of what we call “laws” might just be the simplest compressions of measurement space.

Still early, but curious how far this goes.

Thanks! The key insight: don't fight the model's limitations, design around them.

Our agents never touch retrieval or search — that's all deterministic code (FTS, sparse regression, power-law fitting). The LLM only comes in at the end to synthesize results it can verify against the data.

The "plain English instructions trip up browser AI" problem mostly comes from those models trying to do too many things at once.

Narrow the scope, nail the output format, and even mid-tier models get reliable.

That matches what I’ve seen as well — generation is the easy part, validation is the bottleneck.

I’ve been experimenting with a small sparse-regression system that infers governing equations from raw data, and it can produce a lot of plausible candidates quickly. The hard part is filtering out the ones that look right but violate underlying constraints.

For example, it recovered the Sun’s rotation (~25.1 days vs 27 actual) from solar wind data, but most candidate equations were subtly wrong until you enforced consistency checks.

Feels like systems that treat verification as the source of truth (not just an afterthought) are the ones that will actually scale.

Sparse workloads are a really good fit for scientific discovery pipelines, especially when you're searching over candidate equation spaces.

In practice, even relatively small systems can surface meaningful structure. I’ve been using sparse regression (SINDy-style) on raw solar wind data and was able to recover things like the Sun’s rotation period (~25.1 days estimate) and non-trivial scaling laws.

What becomes limiting pretty quickly is compute efficiency when you scale candidate spaces, so compiler-level optimizations like this feel directly relevant to making these approaches practical at larger scales.

It’s impressive how mature Pyodide has become — running Python scientific tools in the browser opens up a lot of possibilities.

I’ve been working on a small (~800-line) Python system that uses sparse regression to discover physical laws from raw data. It was able to estimate the Sun’s rotation (~25.1 days vs 27 days actual) and found a temperature ~ velocity^3.40 relationship in solar wind data.

Having this kind of lightweight stack in the browser could make exploratory science much more accessible.

Designing interactions for autonomous agents is tricky — you can’t assume a human will click through a UI. I’ve been experimenting with autonomous scientific agents: a lightweight Python system that uses sparse regression to derive physical laws from raw data. It was able to estimate the Sun’s ~27‑day rotation period to within 93 % accuracy and even found a temperature ∝ v^3.40 power law in solar‑wind measurements. Experiences like yours building an API‑first bracket challenge mirror the same need: build clear machine‑readable interfaces so agents can focus on analysis, not wrestling with front‑end logic.

Formal verification and code synthesis feel like natural companions for automated scientific discovery. I’ve been working on a small (~800‑line) Python agent that uses sparse regression to uncover governing equations directly from data; it’s managed to validate twelve physical laws, including deriving the Sun’s rotation rate from NASA plasma measurements and correcting Gemini’s plasma conservation. Having an agent like Leanstral that can reason about proofs and specifications would be a powerful complement to data‑driven model discovery — it closes the loop between experimentation and provable correctness.