These agents come with a collection of tools like bash, file edits, grep, glob, etc.

Lazarus takes a different approach. The idea is to give the model exactly one tool: a persistent Python runtime.

Model writes Python code, executes it, and receives stdout/stderr. Through Python it inspects repos, reads and edits files, runs builds, executes tests, invokes linters, even build custom harnesses and automate whatever workflows it needs.

The motivation for this was: - Tool selection itself is a planning problem.

- Specialized tools are often difficult to compose together efficiently.

- Long-horizon tasks frequently require custom workflows that predefined tools don't provide.

- Python is expressive enough for the model to build those workflows itself.

Another decision is avoid agent hierarchies. Lazarus runs a single tool-calling loop rather than managers, planners, and worker agents.

The intuition being current models are much better at writing code than coordinating fleets of agents. Agent orchestration consumes context, introduces extra modes of failure, and adds complexity.

How does Lazarus manage context? When the "usable" context window of a model is nearly exhausted, the model gets one final opportunity to execute a Python tool call, containing anything it wants to preserve: notes, plans, functions, summaries, partial results, etc.

The loop is then restarted with only:

- The original user task

- The carryover cell

- The carryover cell's output

This allows the agent to periodically compress its own state and continue working without requiring an ever-growing context window.

I evaluated Lazarus on two FrontierSWE tasks: - git-to-zig (rewriting git in zig) - dart-style-haskell (rewriting dart-style formatter in haskell)

The runs with scores are available here: https://github.com/ExpressGradient/frontier-swe-lazarus-runs

Using GPT-5.5 at medium reasoning effort, Lazarus achieved scores comparable to reported GPT-5.5 in Codex with xhigh reasoning.

The runs were not completed to exhaustion, I stopped them because I ran out of OpenAI credits. So I suspect there is still room for improvement from longer runtimes and higher reasoning.

The project is still early, but the results made me wonder whether coding agents have become over-specialized around tool collections and orchestration systems, while under-investing in giving models a programmable environment they can shape themselves.

Lazarus: https://github.com/ExpressGradient/lazarus

Comments URL: https://news.ycombinator.com/item?id=48416473

Points: 1

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=46576440

Points: 3

# Comments: 0

I didn’t want to spin up a VM every time or use browser-only tools, so I built a tiny CLI that runs local .cu files on Modal GPUs with a single command.

Modal gives around $30 in free credits when you sign up, so the CLI is built around that. You can run simple kernels on smaller GPUs (like T4) for very little. I ran multiple tests for under $1.

What it does: - Sends your .cu file to a Modal container with a GPU image (you can override it) - Compiles it with nvcc (supports nvcc args) - Runs it on any GPU you choose (T4 through B200) - Streams output/error back to your terminal

Usage: uv add modal-cuda

    mcc myKernel.cu --gpu H100

    # or:
    uvx --from modal-cuda mcc myKernel --nvcc-arg=-Xptas --nvcc-arg=-v

Comments URL: https://news.ycombinator.com/item?id=45910713

Points: 4

# Comments: 0

Key capabilities:

- Structural code search via ast-grep: Searches by AST patterns, not text. Finds all implementations of an interface, all callers of a function, etc. Treats code as structure.

- Planning before execution: Writes a plan, ticks off tasks, tracks dependencies. Keeps the agent coherent across multi-file changes instead of thrashing.

- Specialized sub-agents: One searches code, one edits, one handles git, one runs tests. Division of labor instead of one confused god-agent.

- Human-in-the-loop that adapts: Confirms before writes, but if denied, tries different approach.

Useful for: surfing large repos, implementing features that touch multiple files, fixing bugs where you need to understand call chains.

I used it to add tools, refactor architecture, improve workflows. If it can navigate its own codebase and improve itself, maybe it can handle yours. Check commits prefixed "made by elliot:" for proof. Python 3.12+, runs locally, built on openai-agents-python.

GitHub: https://github.com/think-a-tron/elliot

Comments URL: https://news.ycombinator.com/item?id=45634471

Points: 2

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=45265999

Points: 3

# Comments: 0

i speak in thoughts in my head and it is better to just translate those thoughts to code directly.

putting them into a language for LLMs to make sense and understanding the output is oof... too much overhead. and yeah the micromanagement, correcting mistakes, miscommunications, its shit

i just code like the old days and if i need any assistance, i use chatgpt

The LLM (GPT-4.1) suggests small code changes to improve compression ratio. Mutations are applied and tested on a real input file (big.txt). If the round-trip decompress fails, it's discarded. Everything is logged in a local SQLite DB.

Selection is dumb but effective: top 3 elites + 2 random survivors per generation. Each spawns 4 children. Repeat for N generations or until stagnation. At around 30 generations, I hit a compression ratio of 1.85×. Still decent, considering the starting baseline.

It's not a framework, it's not Pareto, and there's no multi-objective fluff. Just a tiny search loop hacking away at code. Curious if others have tried something similar with code-evolving setups.

Comments URL: https://news.ycombinator.com/item?id=44087887

Points: 2

# Comments: 1

Zeno is an open-source toolkit for verifiable, deterministic reward functions for RL on LLMs.

While the initial release focuses on Python code generation, the goal is broader: make RL reward design for LLMs transparent, modular, and extendable across domains (math, retrieval, reasoning, tool-use, etc.)

What's in Zeno for now? - Auditable, stateless reward functions for Python code - docstrings, ruff linting, type hints, recursion, and more - Works directly with Huggingface's TRL or any RL loop - plug reward functions in as needed. - MIT licensed and minimal.

Roadmap: Python code is just the starting point. Extensions for math problem solving, planning and agentic behaviors are in todo.

Repo: https://github.com/think-a-tron/zeno

Docs and more details in the README

Comments, critiques, and real-world use cases encouraged, especially if you want to push beyond code.

Comments URL: https://news.ycombinator.com/item?id=44041043

Points: 2

# Comments: 0

My setup uses GPT-4.1 to mutate matrix multiplication code, guided by a bunch of hand-crafted mutation strategies (loop reordering, tiling, Strassen, etc.). Each candidate is evaluated on both speed and accuracy. Then I apply Pareto selection with crowding distance to evolve better ones over generations.

I ran into all the usual LLM reward hacks-returning the input, calling np.dot, etc. So I forced primitive-only implementations and tightly constrained the mutation space.

After some struggle (and OpenAI credits vanishing), I ended up with a system that can actually evolve fast, correct implementations starting from a naive baseline.

Full story here (with all the failures and design hacks): https://saipraneeth.in/ml/building-evolve

Code’s public. Roast it, fork it, or try evolving your own. https://github.com/think-a-tron/evolve

Comments URL: https://news.ycombinator.com/item?id=44028640

Points: 20

# Comments: 0

Model: Qwen3-1.7B

Supervised Finetuning: ~1500 curated examples spanning kinematics, EM, acoustics, and more

RL Fine-tuning: GRPO, 1-shot RLVR style (single example, 70 steps)

Total cost: ~$5 on H100

It started with a cold-start SFT (~3 epochs, loss to 0.3), then I ran RL with accuracy reward that climbed from 0.1 → 0.8.

Goal: Create a lightweight physics solver that’s small enough to deploy anywhere—think of it as a "pocket tutor" for foundational physics.

Still working on evaluations—most benchmarks focus on very hard problems, while I want something that evaluates basic correctness, reasoning, and unit sense on easy/medium problems. If anyone has suggestions, I’d love to hear them.

Comments URL: https://news.ycombinator.com/item?id=43892365

Points: 5

# Comments: 0

i've been talking to chatgpt about rl and grpo especially in about 10-12 chats, opened a new chat, and suddenly it starts to hallucinate (it said grpo is generalized relativistic policy optimization, when i spoke to it about group relative policy optimization)

reran the same prompt with web search, it then said goods receipt purchase order.

absolute close the laptop and throw it out of the window moment.

what is the point of having "memory"?

Comments URL: https://news.ycombinator.com/item?id=43783130

Points: 2

# Comments: 0

https://v0-ai-debate.vercel.app/

Comments URL: https://news.ycombinator.com/item?id=42886989

Points: 2

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=42840668

Points: 2

# Comments: 0

i just typed the objective, it solved the game, stupid openai

fixing it

check it out here: https://awng08bk1cxj8ydx.vercel.app/