Reuben Burls

Neuroscience, markets, machine learning, now proving AI did what it was meant to. Building Aelethion. Surfer, guitarist, professional AI-arguer. Tallinn.

[Reuben Burls @d3rkst3r]

A coding agent can change the code and the test that says its code works. Awkward 😅

Agree the check before it starts. Keep it separate from the implementation. If the check needs changing, make that an explicit decision.

A green tick needs to mean something.

[Reuben Burls @d3rkst3r]

@KowalPrato4o 完成的 task 会把结果和证据通知回发起它的 session。改动本身在各自的分支上提交、开 PR，审查和 CI 通过后由我合并。

The result and evidence go back to the session that created the task. The changes land on branches as PRs, and I merge after review and CI.

[Reuben Burls @d3rkst3r]

agentsocks is open source today.

It's the tool I built so my coding agents could talk to each other without me relaying every message. On Saturday I showed Codex asking OMP to sharpen a tagline and getting the answer back. Today you can run it yourself.

What it does:
- A Claude Code or Codex session can message another session, ask it a question or hand it a tracked task. The answer comes back into the session that asked.
- Messages arrive the way each tool already receives them. Nothing is typed into a terminal, and a message from another agent is never treated as you.
- A busy session isn't interrupted for every message. FYIs are batched into one digest, and floods wait for the end of its turn.

How I use it: Claude plans a feature and coordinates the work. Codex implements. Another model reviews, and its findings go straight back to the agent making the change. When an agent is stuck on a bug, it asks a different model to challenge its diagnosis before it keeps changing code. I still decide what ships.

New in 0.4, and labelled experimental: channels, asking up to 16 sessions one question at once, a live view of every session (agentsocks top), and OpenCode, Hermes, Cursor, Copilot CLI, Gemini CLI and OMP as peers.

Setup takes about a minute. The README has the two commands, and then you open two sessions and ask one to message the other.

It runs on your machine. One machine by default; the gateway that links your own machines over your tailnet is optional and off. MIT licensed. Not affiliated with Anthropic or OpenAI.

Link in the reply. If you try it, tell me what broke.

[Reuben Burls @d3rkst3r]

@tazqen Agreed, added to #2: an unconfirmed stop stays flagged in status and the task list until the worker confirms it or the creator clears it. Before reassigning is exactly when it matters.

[Reuben Burls @d3rkst3r]

How I actually run my coding agents, with real numbers from my dev box.

agentsocks: https://t.co/DATek7SSur

Right now one Linux server is running 24 agent sessions: 6 Claude Code and 18 Codex. In the last 7 days they sent each other 986 messages.

What they use it for:

1. Review across models. Codex writes the change, Claude reviews it, and the findings land straight in the Codex session that has to fix them. Nobody copies text between terminals.

2. A second opinion on bugs. When an agent is stuck, it asks a different model to challenge its diagnosis before it changes more code.

3. A small software factory. One session orchestrates. It hands out tracked tasks with an owner, acceptance criteria and an expiry. Workers mark them accepted, done or failed, with the evidence attached, and the orchestrator hears about every change instead of polling terminals.

4. One boss per worker (new in 0.4). Each worker follows one driver. Messages from anyone else arrive as information, not orders, so twenty sessions don't end up instructing each other.

5. Changing my mind. Last night a research run handed tasks out to other sessions. I changed course, one message stopped the work, and the task closed with a note of what had and hadn't been done.

What it doesn't do: decide what ships. I still do.

Free, MIT, runs on your machine. Setup is in the README.

[Reuben Burls @d3rkst3r]

@RenXLog Agreed, and it matches what already happens for expiry: a worker can still report a late done or failed on an expired task. An unconfirmed stop should work the same way. Added to #2.

[Reuben Burls @d3rkst3r]

@pzfzqym The agentsocks log stays local, and it keeps a hash of each message rather than the text. What a reviewer needs goes in the PR itself: the findings, what changed because of them, and the evidence.

[Reuben Burls @d3rkst3r]

Today you can see the first but not the second. message_status shows when the cancel was shown to the worker; nothing yet proves its running commands have stopped. That's the gap issue #2 is about: https://t.co/vqrMkOKCrD. Until it lands, ask the worker to stop and close the task itself, with a note of what ran, before you reassign.

[Reuben Burls @d3rkst3r]

@federicodonaton Thanks Federico, happy to connect.

[Reuben Burls @d3rkst3r]

Using several coding agents has made me pay much more attention to how work passes between them.

I use Claude Code and Codex on their subscriptions. For our workload, that makes heavy coding use affordable, and I can ask one to review the other's changes.

But I was carrying the review requests and findings between sessions myself.

A useful handoff needs more than “check this”. The reviewer needs the original task and something concrete to inspect. Its findings need to get back to the session making the change. Then someone needs to check whether the fix actually addresses them.

Buying access to another capable model doesn't organise that work for you.

We built a tool to handle the messaging between Claude Code and Codex while keeping each in its own coding client.

It's one of several projects I've accumulated while building Athena. I tend to get excited, overengineer things and move on before I've properly shared them. Some have nevertheless become tools we keep using.

We're going to start releasing those as open source through Aelethion.

Tomorrow I'll show the messaging tool doing a real handoff, including what it leaves up to you.

[Reuben Burls @d3rkst3r]

@cloneisjun That's the part I care about most: findings arrive where the fix happens, so nothing gets lost in a copy and paste.

[Reuben Burls @d3rkst3r]

I built agentsocks because I wanted my own software factory.

Claude plans a feature and coordinates the work. Codex agents implement it. OMP reviews independently and sends its findings back to the agent making the changes.

Or an agent gets stuck debugging and asks another model to challenge its diagnosis.

I wanted those conversations to happen between their own coding sessions, without me relaying every message.

The clip shows a simple round trip: Codex asks OMP to sharpen an Athena tagline, OMP replies, and the answer comes back into Codex.

We’re preparing agentsocks for open source through Aelethion.

[Reuben Burls @d3rkst3r]

@RenXHQ Makes sense. In agentsocks a reply goes back to the sender's address, so the review and fix rounds stay between the same two sessions.

[Reuben Burls @d3rkst3r]

@Rylvo_AI Per action is the right unit. "Has access" should mean read yes, draft yes, send only with a named approval.

[Reuben Burls @d3rkst3r]

I've started connecting the apps I use to my AI tools through their APIs, and it's made me realise how little "the agent has access" actually tells you.

Access to my inbox could mean reading an email, drafting a reply, sending it, or forwarding the whole thread somewhere else. Those are very different permissions, and getting the last two wrong costs a lot more than the first two.

A CRM is the same. Looking up a customer and changing their record shouldn't come bundled together just because the agent can use the app.

So for each connection, I think it's worth writing down three things:

• What it can do on its own
• What needs my approval first
• What it should never touch

Then check whether the integration actually enforces those limits. "Ask me before sending" in a prompt is an instruction the model will usually follow, but it isn't a permission. If the connection can still send, the agent can still send, and the only thing stopping it is the model behaving.

How much you can enforce depends on the tool. Some let you limit what a connection can do, for example read-only access or a smaller set of actions. Others are closer to all or nothing, which is worth knowing before you connect them.

If you've connected agents to real accounts, how are you drawing these lines?

[Reuben Burls @d3rkst3r]

@AtonimusAI That's the right test: check the provider's own audit log, not the agent's promise to ask first. And agreed, if the connector is all-or-nothing, the production inbox stays disconnected until something narrower sits in front of it.

[Reuben Burls @d3rkst3r]

@pixlode Tests and type checks run before anything is handed over, and the handoff carries the proof with it: test output, the commit. Then an independent review tries to break it. In agentsocks a task marked done carries its result and evidence, so the next agent sees proof, not a claim.

[Reuben Burls @d3rkst3r]

@pennyp973 Mostly fresh, with the state in git, the tests and a short plan file rather than long notes. The handoff itself is what I fixed: the two sessions now message each other directly instead of me relaying. https://t.co/ltKz4lXFGA

[Reuben Burls @d3rkst3r]

@DFakkeldy Nice, that's very close to my loop. With agentsocks the reviewer stays the same live session, so its context carries across rounds without resuming threads by script: https://t.co/ltKz4lXFGA

[Reuben Burls @d3rkst3r]

@adityabhatia89 Mostly the review findings and the why behind a change, pasted between terminals. That's what I built agentsocks to remove: the sessions message each other directly, and the reviewer can ask the author about intent. https://t.co/ltKz4lXFGA

[Reuben Burls @d3rkst3r]

@mirajobs I brief the reviewer to break the change, not bless it, and every finding comes with a severity and file:line evidence, so nits are labelled as nits. Yesterday that caught a real one: my own change would have quietly removed an approval prompt in Codex.

[Reuben Burls @d3rkst3r]

@pzfzqym That's the idea. Logged handoffs plus a human owning the merge turns "why did it do that" into a lookup.

[Reuben Burls @d3rkst3r]

No, it doesn't wait. Cancel is immediate on the record, and the worker hears it at its next tool call, so a call already running can still finish. Last night the worker closed the task itself with a note, which is why that record was clean. A creator's cancel can't capture that yet, so I've opened an issue for a stop the worker confirms: https://t.co/vqrMkOKCrD

[Reuben Burls @d3rkst3r]

@Kantorcodes Already up as a draft: https://t.co/oVhiitLFTY

command.agentsocks.json plus a 133-case fixture, and the checks are green. Happy to tune the severities to your conventions.