SafeDusk

Very cool! Excited to incorporate this into https://toolkami.com which is built upon RLM. Thanks for the great work!

Am excited about RLM too! That's why I built https://toolkami.com so that people can try it easily for agentic workflows.

Working on https://toolkami.com that enables plug and play Recursive Language Model for increased context size and better recall.

Sandboxing is going to be of growing interests as more agents go “code mode”.

Will explore this for https://toolkami.com/, which allows plug and play advanced “code mode” for AI agents.

If I were to add, "winter" is the best time to find snow, and there is enough snow for everyone.

Not surprised OpenAI is not there, I struggled so much with telemetry in Codex that I had to build my own one Codex Plus (https://github.com/aperoc/codex-plus) -_-

Seems like it can be a standard the project can adopt.

These can also be observed through OTEL telemetries.

I use headless codex exec a lot, but struggles with its built-in telemetry support, which is insufficient for debugging and optimization.

Thus I made codex-plus (https://github.com/aperoc/codex-plus) for myself which provides a CLI entry point that mirrors the codex exec interface but is implemented on top of the TypeScript SDK (@openai/codex-sdk).

It exports the full session log to a remote OpenTelemetry collector after each run which can then be debugged and optimized through codex-plus-log-viewer.

Using https://github.com/aperoc/toolkami which just spins up a worktree with pre-configured Docker containers.

Sad that a lot of these are for Claude Code and not Codex which I uses more, so I started https://github.com/aperoc/codex-plus which has telemetry built-in, now moving to build a Ralph loop on top of it.

hehe thanks! as a self taught AI engineer, might take awhile =D

UV script enabled me to distribute a MCP client or server in a single file[0].

[0]: https://blog.toolkami.com/mcp-server-in-a-file/

I think both Cursor and Cognition and going in the same direction of SWE-grep[0].

SWE-grep was able to hit ~700tokens/s and Cursor ~300token/s, hard to compare the precision/recall and cost effectiveness though, considering SWE-grep also adopted a "hack" of running it on Cerebras.

I'm trying to kickstart a RL-based code search project called "op-grep" here[1], still pretty early, but looking for collaborators!

[0]: https://cognition.ai/blog/swe-grep [1]: https://github.com/aperoc/op-grep

Not sure man, I specifically stated this in my README way before this post: https://github.com/aperoc/toolkami/blob/main/README.md#comma....

I mean it's not much, but the concept just resonates with me and I want to share it. Sad I can't share even simple opinion nowadays ...

One of the core design principles at https://github.com/aperoc/toolkami

Great to see progress being made here! I had tons of fun using AlphaEvolve to optimize Perlin Noise[0]

[0]: https://blog.toolkami.com/alphaevolve-toolkami-style/

I recommend reading Shopify CEO Tobi's try[0] for good example of how Ruby's block behavior and meta-programming makes it easy to create a single file, shell wrapper.

[0]: https://github.com/tobi/try/blob/main/try.rb

And I'm looking for a problem to spend my next decade on ...

Inspired by SWE-grep, I've started a repo to educate myself on it here https://github.com/aperoc/op-grep.

I've drafted an architecture, with the steps mainly as so: 1. Collect actions (grep/glob/read) policies either from usage logs or open datasets 2. Optimize by removing redundant actions or parallelization 3. Train model on optimized action policy 4. Release model as a single file, MCP tool (Refer to repo for visual diagram of the architecture)

I've just released the base model and added `openai_forwarder.py` to start collecting action policies.

Looking for more eyes and contributors to make this a reality, thanks!

I like to think of subagents as “OS threads” with its own context and designed to hand off task to.

A good use case is Cognition/Windsurf swe-grep which has its own model to grep code fast.

I was inspired by it but too bad it’s closed for now, so I’m taking a stab with an open version https://github.com/aperoc/op-grep.

Kickstarting an exploratory open version here https://github.com/aperoc/op-grep since it doesn't look like they will do it.

Any plans to offer this as a tool/MCP server for other coding agents or is it going to be Windsurf exclusive?

That is why a minimal framework[1] that allows me to understand the core immutable loop, but to quickly experiment with all these imperative concepts is invaluable.

I was able to try Beads[1] quickly with my framework and decided I like it enough to keep it. If I don't like it, just drop it, they're composable.

[0]: https://github.com/aperoc/toolkami.git [1]: https://github.com/steveyegge/beads

Release a CLI for my open source project: https://github.com/aperoc/toolkami

It is a modified version of Shopify's CEO Tobi try implementation[0]. It extends his implementation with sandboxing capabilities and designed with functional core, imperative shell in mind.

I had success using it to manage multiple coding agents at once.

[0]: https://github.com/tobi/try

If anybody is looking for a simple CLI tool to spin up parallel agents, have a look at https://github.com/aperoc/toolkami!

Shameless plug on https://github.com/aperoc/toolkami here which is designed to be simple enough such that you can truly "own" and understand your agents.

It has a CLI which spins up sandbox for your agents, and has curated tools for your agent to be useful.

Building close to this space[0] too but starting with low code instead of no code. Still wondering in node-based GUI is the way to go, another alternative is something like Lovable where it is entirely chat based.

[0]: https://github.com/aperoc/toolkami

@kixpanganiban Do you think it will work if for refactoring tasks, we take aways OpenAI's `apply_patch` tool and just provide `cut` and `paste` for the first few steps?

I can run this experiment using ToolKami[0] framework if there is enough interest or if someone can give some insights.

[0]: https://github.com/aperoc/toolkami

Hi HN,

I hope someone will find this useful.

On a side note: if you're already using Try and would like to see this incorporated, I've opened an issue here: https://github.com/tobi/try/issues/40. Give a like or comment to make this more possible!

Am keen to hear TUI tips for coding agents parallelization as feedback for improvements. How are you guys doing it?

self-plug: adding https://github.com/aperoc/toolkami to the list!

Have a look at https://github.com/aperoc/toolkami if you want a single, file implementation of a TUI parallel agent interface.