tarasyarema

Hi there!

We've been building https://github.com/desplega-ai/agent-swarm in the open for a while, and one of the things we wanted to do since the start is find how powerful it can be to push for a code mode like env for the swarm.

We tried it and we managed to reduce up +90% of token costs by using swarm scripts (the code mode variant we implemented) for some of our schedules.

This is game changer, as we are able to

1. Run those schedules faster 2. Cheaper 3. More reliably

Been thinking a lot now on how we should prompt and change the default templates to force the agents to build on top of this. If it can be re-used or it's a recurring thing -> scripts.

Thoughts? Have you seen this type of improvements in your setups?

Cheers,

On why Polsia is the biggest slop machine we've seen to date.

If you want to still use your anthropic sub after 15th of June, you could try this out.

Still trying to figure out if there will be ways to "bot check" from Anthropic side for this workarounds.

Hi there!

For a while we've seen companies focused solely on the coding agent part, and specially building harnesses. We thought it would be interesting to go in another direction: building on top of them.

Building on top of them allowed us to create a system that can be plugged where you work (e.g. Slack, Linear, Github, Gitlab, email, etc) and work as a peer. It really feels like a new teammate that works with you.

Some of the core components of it are:

1. Plug in any harness: codex, Claude Code, Claude managed agents, Devin, pi, etc.; 2. Memory layer. It's an abstraction, hence you may build your own implementing an interface; 3. Communication layer where you work; 4. Multi agent architecture with single lead (we started with any agent as the entrypoint and we saw lead only was better).

We are building it in public, and today we just hit 400 stars (wow). Also we have some companies that are trying to integrate it into their teams (+50 people) with promising results.

I'm really curious what you think about it, and how do you see this pattern emerging and being used by companies that want to go truely agent-native.

Any feedback or suggestions are more than appreciated!

Cheers,

Hey there HN!

I loved the chat sdk for node, but I wanted to use it in Python, so I let my agent-swarm run in the night to port it (it only costed $500 in claude usage xD).

Performing some E2E tests now, and will be releasing to pypi as `chat-py` with the adapters as separate packages (as the chat sdk).

My goal is to keep it in sync on a daily basis.

Cheers!

Hi there, welcome!

The API still works fine tho, i.e. via https://hacker-news.firebaseio.com/v0/item/<n>.json

This is the newest post I can see: https://news.ycombinator.com/item?id=47233969 (I did a good old binary search :D)

jaja no, the replies to this post I did them manually. The ones from your link were a test I did a while ago unrelated to the swarm :D

funny you found that XD

Does maintaining one count? If so it does already :D

100%, my tldr from that paper is: never use /init basically

Yeah, saw that paper. And I have the following notes on it:

1. Agents update those files themselves, but currently with my oversight and guidelines (from the UI you can even see it's contents)

2. Measuring this is extremely hard, if not impossible. One of the goals of the swarm is to help me on random tasks that can span a lot of different pieces, not just implementing a feature.

Before last week, we did not have the memory and identity files. And, from an empirical pov, I can say that the general feel improved a lot. I see that in similar situations it does not perform the same mistakes. Also, what is stored in those files generally is something that the agent CAN NOT find using it's tools (like the paper suggest to avoid) which actually helps.

In any case, the swarm created a research on this topic a few days ago https://github.com/desplega-ai/agent-swarm/pull/86 maybe I'll iterate on it and see what we can get :D

100%. I believe the best thing to do now is find ways to push the limits of what works and what not, which will help find the following limits, and keep going

Thanks! I too believe this, unsure how it will actually look, but the pattern of AI employees is clearly rising.

I mean you can check the closed PRs in the repo, 95% of them were done by the swarm. And a similar pattern is happening for our customer facing products.

I think you focused on the bonus point, rather than the first part (which is the relevant one).

https://github.com/desplega-ai/agent-swarm/pulls?q=is%3Apr+i...

This may not run in your machine, and you can interact with it from channels like Slack or Github.

I have to give it a try. Will need to check for Anthropic compatible APIs (I know openrouter have one) and see how it works. Will def try it out and post some benchmarks in the repo!

I use this a lot for multi-tasking, let me explain.

Currently at my startup (and in the past when I worked on a bigger company) I have ton of random tasks I need to tackle during the day: from Sentry issues, to analytics on usage, roadmap implementation, customer support. Some of them required deep focus, some of them don't.

Since we have the swarm running for our company my day to day hasn't changed that much in terms of the work I do locally. What it changed is that I can start delegating a lot of my backlog and chores to the swarm. It will do it, iterate, delegate, review, and finally send me a PR or report to check. I check those in the morning and night, and that's it.

I added it to our customer channels, were it has scoped access to the customer setup, and help me debug the issues, and offer a frontline ultra-personalized support.

I see it as a team of interns that just do stuff for you. And good thing: they learn from their mistakes to (hopefully) do not make them again (compounds).

As a random bonus: given the swarm knows what we do and how we work, I just ask them to go out there and figure out any relevant news or posts I should check each morning, and I get a personalized digest to read while I make coffee.

That's literally what it does :D I.e. it uses the auth token to use claude code (the CLI binary). Check the code here: https://github.com/desplega-ai/agent-swarm/blob/main/src/com...

Yes, but in this case it uses directly the claude CLI and it's self-hosted, i.e. personal use. Hence, as far as I know, it's not against terms.

First of all, thanks!

And agree on the open questions. Our goal is to keep experimenting and actually figure out how we agentic coding falls short in different scenarios and how that could be solved.

For instance, on our own projects, in some cases it requires different approaches. E.g. in our core product we power-use stuff like pm2, AGENTS.md special instructions, testing strategies dogfooding our own qa-use and special claude code commands that we found work best. In other repos, we have slightly different approaches.

Still we are far from autopiloting a lot of the stuff we build. But at the same time we are getting to a point where changes are done much faster, and the agents have more of a complete toolset for their validation, which makes it easier to supervise too.

Yes, like here's the daily compounding schedule the lead created:

---

Task Type: Daily Reflection — "My Compounding Journey"

You are Lead. This is your daily morning reflection routine. Do the following:

1. *Review yesterday's work*: Use `get-tasks` with status "completed" to see what got done. Use `memory-search` to find any learnings or patterns from yesterday.

2. *Reflect on the day*: Think about: - What went well? What tasks shipped cleanly? - What was harder than expected? Why? - Did any worker struggle? Could coaching or identity updates help? - Were there any repeated patterns (good or bad)? - Did we compound — did yesterday's work make today's work easier?

3. *Identify improvements*: Pick 1-3 concrete things to improve. These could be: - A coaching update to a worker's identity - A process change - A new memory to save - A tool/setup improvement

4. *Post to Slack*: Use `slack-post` with channelId "<redacted>" to post a message titled something like "My Compounding Journey — [date]". Keep it concise (3-5 paragraphs max). Include: - Brief summary of what shipped - Key insight or learning from the day - What you're improving based on it - If it was a quiet day with no tasks, say so honestly — "Quiet day, nothing to compound on" is fine.

5. *Act on improvements*: If you identified coaching updates or memory writes, do them now.

Keep the tone honest and direct. This isn't a performance report — it's genuine self-improvement.

---

As it has context on it's own system (codebase) it had also proposed some changes via PRs each morning

I believe that it’s a matter of evolution. You start small and find what works fir you and the project. Then iterate and see how to remove yourself from it more.

I actually wrote about this concept here if that’s something the might interest you: https://www.tarasyarema.com/blog/2026-02-18-introducing-sema...

Yes, I spent too much time meta programming while working on desplega.ai (my startup). And I believe currently the best approach is a mix.

Have the swarm work on stuff you could delegate to an intern and basically have the feedback loop with it in slack and github.

On the other hard locally focus on the hard things you want to control.

Thanks! In fact yes, initially when we built this openclaw was not there yet. And after trying it was clear that I could adapt swarm to have a similar approach. I believe the self improvements part is really key.

Today I did the audio note test, it literally installed all needed and adapted its memory to use that whenever I send followup audio notes from Slack :D

Yeah, I saw different approaches to solve this problem. On the native one I think it's really limited now. The main pain point is that the teams are scoped to a single session, which feel really off to me. Also, it's local only. But we'll see what Boris will ship I guess...

Good thing I just gave it access to my prod db, and agent mail inbox per worker and git write permissions...

hope it does not go rogue...

Hello there HN!

We've been building agent-swarm since November last year, and we wanted to share an update on its capabilities, specially focused on the self-learning part.

After all the hype with OpenClaw, I thought that the existing architecture needed a rewrite to make it compounding. Hence, last week we implemented a self-learning core to the swarm so that it can compound.

It follows really similar ideas to the OpenClaw where there's a SOUL.md and IDENTITY.md. As it's docker based, it has some personal and shared volumes that persist, so those are used to track re-usable scripts and notes. We also added SQLite based memory that agents can write to and query. The interesting part about it is that there's personal and shared memory, which allows the lead to propagate learnings across the swarm!

We've been using it non-stop for the last week, and I already see the compounding effects. E.g. we have a morning scheduled task that makes the lead assess the previous day work, and figure out ways to improve it's processes, and it got better!

To end, note that it's fully OSS and it's as easy as deploying a docker compose to a VPS, or even locally. It's core is based on an MCP that the lead and all workers share, which allows you to impersonate the lead locally to control the swarm from your coding agent too!

We implemented a super simple UI at app.agent-swarm.dev that runs in the browser only so you can put your API url and key to see it in action.

P.S.: It uses the claude CLI only now, so there should be no issue with the Anthropic terms, and it's really thought to be self-hostable.

P.S.2: Obviously, all the agent swarm code has been written at 95% by agent swarm via Slack :D

If you have doubts or questions about the architecture, or what we are planning to build next, happy to chat in the comments section!

Working on multiple things focused mainly on how to push the limit of validating changes in an automated way in the world of AI:

- https://github.com/desplega-ai/qa-use CLI to control browsers and tests locally, coding agent friendly - https://github.com/desplega-ai/agent-swarm OSS agent swarm that can be deployed with docker compose using Claude - https://desplega.ai platform that supports qa-use backend

Cheers!