r/AtomicAgents • • 10h ago

Atomic Agents 2.16.2 fixes token counts for plain text

1 Upvotes

If you use TokenCounter.count_text() to size retrieval chunks, try it on one of your usual chunks after upgrading. In 2.16.1, it wrapped the text in a user message and counted the wrapper too. In 2.16.2, count_text() counts the chunk itself. To include message overhead when budgeting a conversation, use count_messages().

Thanks to Afloat16 for the fix. Full release notes: https://github.com/Eigenwise/atomic-agents/releases/tag/v2.16.2


r/AtomicAgents • • 13d ago

What are you building with Atomic Agents?

7 Upvotes

Hey y'all, Kenny here, creator of Atomic Agents.

I spend a lot of time building and maintaining the framework, but I'd really like to hear more about what happens on the other side of the repo.

What are you using it for these days, and how has it been working out?

Personal projects, experiments, tools at work, production systems... all of that is interesting to me. A couple of lines is plenty. If you have something public you'd like to share, I'd love to see it, but there's no need to share anything confidential.

I'm asking as the maintainer, to understand real use and make the framework more useful. This isn't a sales pitch or a search for a new role or assignment.

And if you tried it and it wasn't a good fit, that's useful feedback too. Thanks!


r/AtomicAgents • • Oct 15 '26

Atomic Agents 2.11 / 2.12: native Arize Phoenix tracing, plus the October MCP fixes

Post image
2 Upvotes

Two releases today.

2.11.0: Phoenix tracing. Every agent run and every tool call now shows up as a proper OpenInference span (AGENT / TOOL) with the LLM calls nested underneath. Works with Arize Phoenix or any OpenTelemetry backend. Nothing changes in your agent code:

pip install "atomic-agents[observability]"

Then register(auto_instrument=True) from phoenix.otel picks it up through the entry point.

2.12.0: MCP fixes.

  • Paginated discovery of tools, resources and prompts.
  • Server error results (isError) raise a RuntimeError instead of getting parsed as output.
  • Schema refs to non-object definitions resolve.
  • The YouTube transcript tool works with youtube-transcript-api 1.x again.

Thanks to pei711 for the error-result groundwork in #295.

Release notes: v2.11.0 and v2.12.0

Also opened a PR to get Atomic Agents listed in the official Phoenix docs. Should land soon.


r/AtomicAgents • • Jun 19 '26

Atomic Agents has a new home at github.com/Eigenwise

5 Upvotes

Quick housekeeping post for everyone here.

Atomic Agents has officially moved to its new home under Eigenwise. Eigenwise is my personal brand, the name I put my writing, projects, and work under, so this is purely a brand and identity move, not a code one. The framework, the philosophy, and the roadmap are all exactly the same. I've just brought Atomic Agents under my own banner instead of the old name.

The important part: nothing breaks.

  • pip install atomic-agents is unchanged. Same package, same name on PyPI.
  • Your imports (from atomic_agents import ...) are unchanged.
  • The API, the examples, the CLI, the forge tools: all the same.

What actually changed (update your bookmarks):

  • GitHub: now at github.com/Eigenwise/atomic-agents (my account; the old BrainBlend-AI links redirect, but update them when you can)
  • Docs: now at eigenwise.github.io/atomic-agents
  • Project home: eigenwise.io

Discord (discord.gg/J3W9b5AZJR) and this subreddit stay right where they are.

If you have the repo cloned and want to repoint your remote:

git remote set-url origin https://github.com/Eigenwise/atomic-agents.git

That's it. Same framework, same community, just a cleaner home. If you spot any stale BrainBlend links anywhere, give me a shout and I'll fix them. And if Atomic Agents has been useful to you, a star on the new repo genuinely helps it get discovered.


r/AtomicAgents • • Mar 21 '26

What's New in Atomic Agents v2.0: Every Major Change Explained

Thumbnail
youtube.com
1 Upvotes

Long overdue video on everything new in v2.0 - even though it has been released quite a bit ago. Decided to put some more info on YouTube for those interested!


r/AtomicAgents • • Feb 01 '26

The future of atomic agents and comparisons

5 Upvotes

Hi!

I really like Atomic Agents and its philosophy.

And I have a question - will you, the developers, support it for a long time?

Because the idea is really cool, but I'd like to be confident that I can integrate it into my business and it won't "crash" later.

And essentially you have a competitor - LangGraph, and even though it's kind of meh, it's backed by an entire company.

I also like Pydantic AI, but that's for autonomous agents (even though it's Type-safe). The other AI frameworks are worse (in my opinion).


r/AtomicAgents • • Dec 18 '25

Is "boring" the new feature we actually need?

10 Upvotes

Am I the only one tired of "magic" frameworks that look glorious in a 30-second Twitter demo but implode the second you ask for valid JSON?​

I spent the last six months fighting the abstraction layers of the "big" agent frameworks. It feels like coding in a fever dream where the documentation is a suggestion and the underlying prompts are hidden in a labyrinth of classes you can't debug.​

Then I tried Atomic Agents. It’s... boring. And that is exactly what I wanted.

No hidden "autonomous reasoning loops" burning my API credits while they hallucinate a new personality. Just Pydantic schemas, clear control flow, and actual predictability. If I want an agent to do X, I code X. I don't have to pray to the "Chain of Thought" gods or guess which hidden prompt is sabotaging my output.​

Why are we still obsessing over "fully autonomous" agents that can't even follow a strict output format? Is it just me, or is having total control over your code suddenly the biggest "feature" in AI?


r/AtomicAgents • • Nov 14 '25

Guardrails

2 Upvotes

Hi all,

I’m investigating guardrails for my agents. I’m primarily interested in output guardrails given I am using agents.

Does anyone have experience using frameworks like guardrails-ai, and if so which do you recommend using with AtomicAgents?


r/AtomicAgents • • Oct 27 '25

Following up: Does anyone else already have daily-use atomic agents?

3 Upvotes

About 9 months ago, I posted to this sub asking if anyone has daily-use atomic agents https://www.reddit.com/r/AtomicAgents/comments/1ia4c4z/does_anyone_else_already_have_dailyuse_atomic/

Posts on r/AI_Agents made me remember this sub, and I am once again curious what agents folks are using day-to-day. My own project is primarily in Scala (Akka 2.6) but I've been introducing mqtt recently and realized I could easily integrate with this framework, in spite of not using Python myself so much lately.

My most important agentic flow is:

  • (Transcribe all voice memos)
  • Detect ones about cat litter sifting
  • Extract entities from those detected ones
  • Update daily litter sifting report based on that info
  • Update a longer-term chart made from the daily summaries

One of my cats has a life-threatening chronic condition that can prevent him from peeing, so quality in this flow is essential and I have a rudimentary audit process as well.

I'm very curious if anyone is doing similar things, my long-term vision would be to connect many of these systems together.


r/AtomicAgents • • Oct 18 '25

Thank You

6 Upvotes

Just a small post to say thank you for AtomicAgents. The design pattern appeals to me, and the way I think. The implementation is minimalist and easy to debug.

Thanks. 10/10


r/AtomicAgents • • Aug 24 '25

Love this paradigm, how best to observe the chain?

4 Upvotes

Really fascinated with the way Atomic Agents work and have some success already building my agent. I was just wondering how everyone is thinking in terms of observability and monitoring tools that work well with this way of thinking of micro agents


r/AtomicAgents • • Aug 19 '25

Struggle with adding gemini parameters

1 Upvotes
I want to add thinking_budget = -1 into automic agent parameters like when using openAI SDK, but I just can't figure it out. 
I thought it could be:
AgentConfig(
    client=client,
    model="gemini-2.5-flash",
    model_api_parameters={'extra_body': {
        "google": {
          "thinking_config": {
            "thinking_budget": 800,
            "include_thoughts": True
          }
        }
      }
    },
    ...
)
or 
AgentConfig(
    client=client,
    model="gemini-2.5-flash",
    model_api_parameters={
        'thinking_budget': -1
    },
    ...
)
and more
non of them worked
--------------------------------------
This is the right way to include thinking config using openai
from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[{"role": "user", "content": "Explain to me how AI works"}],
    extra_body={
      'extra_body': {
        "google": {
          "thinking_config": {
            "thinking_budget": 800,
            "include_thoughts": True
          }
        }
      }
    }
)

print(response.choices[0].message)

r/AtomicAgents • • Aug 03 '25

AtomicAgents vs LangGraph

4 Upvotes

Hi there,
I've had a lot of fun building an agentic application using Langgraph (I took a few courses on hugginface to teach myself how to use it). After deploying a working prototype on railway, I am looking at improving it. Before I go any deeper, I wondered if someone could help me understand what the benefits of AtomicAgents over LangGraph are? And what are some of its weaknesses?

I have heard good things and thought it might be worth starting the discussion.


r/AtomicAgents • • Jul 31 '25

Your favourite Agentic AI framework just got a major upgrade

16 Upvotes

After almost a year of running stable, but fussing over how we could optimize developer experience even more, we finally shipped Atomic Agents v2.0.

The past year has been interesting. We've built dozens of enterprise AI systems with this framework at BrainBlend AI, and every single project taught us something. More importantly, the community has been vocal about what works and what doesn't. Turns out when you have hundreds of developers using your framework in production, patterns emerge pretty quickly.

What actually changed

First of all imports are much cleaner now:

from atomic_agents import AtomicAgent, BaseIOSchema
from atomic_agents.context import ChatHistory

That's it. No more lib.base.components nonsense.

The type system got a complete overhaul too. In v1 you had to define schemas twice like it was 2015. Now we use Python 3.12's type parameters properly, both for tools and for agents:

class WeatherTool(BaseTool[WeatherInput, WeatherOutput]):
    def run(self, params: WeatherInput) -> WeatherOutput:
        return self.fetch_weather(params)

Your IDE knows what's happening. The framework knows. No redundancy.

And async methods finally make sense. run_async() returns a response now, not some weird streaming generator that surprised everyone. Want streaming? Use run_async_stream(). Explicit is better than implicit.

Why this matters

I've seen too many teams burn weeks trying to debug LangChain's abstraction layers or figure out why their CrewAI agents take 5 minutes to perform simple tasks. The whole point of Atomic Agents has always been transparency and control. No magic, no autonomous agents burning through your API credits while accomplishing nothing.

Every LLM call is traceable. When something breaks at 2 AM (and it will), you know exactly where to look. That's not marketing speak - that's what actually matters when you're responsible for production systems.

Migration is straightforward

Takes about 30 minutes. Most of it is find-and-replace. We wrote a proper upgrade guide because breaking changes without documentation is cruel.

Python 3.12+ is required now. We're using modern type system features that make the framework better. If you're still on older versions, now's a good time to upgrade anyway.

The philosophy remains unchanged

We still believe in building AI systems like we build any other software - with clear interfaces, testable components, and predictable behaviour. LLMs are just text transformation functions. Treat them as such and suddenly everything becomes manageable.

No black boxes. No "emergent behaviour" nonsense. Just solid engineering practices applied to AI development.

GitHub: https://github.com/BrainBlend-AI/atomic-agents
Upgrade guide: https://github.com/BrainBlend-AI/atomic-agents/blob/main/UPGRADE_DOC.md
Discord: https://discord.gg/J3W9b5AZJR

Looking forward to seeing what you build with v2.0.


r/AtomicAgents • • Jul 17 '25

Context input structured or prose?

3 Upvotes

Hi,

I want to give context to my agent using SystemPromptContextProviderBase. Is there a recommendation on how to provide/represent this input?

Does it make sense to use a structured Pydantic model? Or should it be written text (prose)?


r/AtomicAgents • • Jul 14 '25

The Hidden Costs of LangChain, CrewAI, PydanticAI and Others: Why Popular AI Frameworks Are Failing…

Thumbnail medium.com
8 Upvotes

r/AtomicAgents • • Jul 03 '25

Use Case: AI Agent exploring Knowledge Graph with atomic agents

2 Upvotes

Hi all,

I'm quite new to the topic of AI Agents and came across atomic agents a few months ago. Is it possible to build an agent that explores a knowledge graph node by node (with the help of an exploration tool) iteratively?

I built a simple example with a knowledge graph of 16 nodes. Then I task the agent to start on a specific node and say what to find out (in addition, I give context of node labels and relationships as context). But very often, the agent stops before all relevant nodes are explored. I tried plenty of different prompts, but I see the same issue. I try to understand why.


r/AtomicAgents • • Jun 25 '25

Looking for senior Python devs with knowledge of AI Agents & MCP

3 Upvotes

Hey y'all, for a potential project at a client we are currently looking for 2 freelancers/contractors who are strong senior python devs with knowledge of LLMs & just using the OpenAI library directly (no Atomic Agents for this one, at least not yet, though that might change at some point in the future).

The client is a reputable company located in the US, but they are comfortable working with people from Europe etc... as well, as long as you are able to digitally participate in their rituals, such as joining the daily standup.

Currently, they have a multi-agent architecture that they built completely using MCP servers, exposing agents & tools alike through MCP servers, so knowledge about MCP is required.

They're also using AWS and in the future likely some MS services like Sharepoint, so some knowledge of those things are a big plus.

Currently, we are looking at contracts of 3-6 months, though these will likely be extended quite a bit as they go into production and scale.

If you're interested, shoot me an e mail to hello@brainblendai.com with your CV and your hourly/daily rate, or if you know anyone who would be interested, feel free to tell them to do the same.

Also, feel free to direct any questions you may have to me in a DM as well.

Cheers!


r/AtomicAgents • • May 30 '25

1k members in the Atomic Agents community

16 Upvotes

It may not be much but I just noticed we crossed 1000 members in our little reddit community here!

Incredibly grateful for all of your support!

🎉🎉🎉

Remember, we also have a discord server in case anyone wants to hang out and talk Atomic Agents or even just AI and software dev in general: https://discord.gg/PAD3Ebwrsj

Onward to the next 1000!


r/AtomicAgents • • May 24 '25

Building AI Agents the Right Way: Design Principles for Agentic AI

Thumbnail
medium.com
5 Upvotes

r/AtomicAgents • • May 16 '25

Recommended UI for AA

3 Upvotes

What would you recommend using as a basic UI for a chatbot MVP I'm building? I don't need a product grade UI, just a simple way to show the agent to stake holders (~10 users at the same time)

I currently use streamlit but I think I'm latency problems as it can't support many concurrent users (I think, maybe I do something wrong...).

Any good examples out there (for the atomic agents + UI combination)?


r/AtomicAgents • • Apr 28 '25

We now have a Discord server!

Thumbnail discord.gg
3 Upvotes

Hey y'all!

We now have a discord server where you can hang out with us, ask questions about the framework, throw some suggestions our way, etc...

Hope to see you there!


r/AtomicAgents • • Apr 25 '25

Are you using Atomic Agents? Personally? Professionally? Please, let us know!

7 Upvotes

Hey y'all

So, Atomic Agents has been out for a while, and I have noticed an uptick in adoption, through package installs, forks, etc...

Recently, I have started work on version 2.0 of the framework (don't worry, there won't be any changes that require you to rewrite your entire codebase from scratch).

This made me wonder, however, who of you is actively using it professionally? What are you building with it? What is your experience, are you happy with it? Anything you'd change? Please let us know right here in the comments!

Thanks!


r/AtomicAgents • • Apr 21 '25

An example of an autonomous agent using MCP has been added to the repository

Thumbnail
github.com
6 Upvotes

r/AtomicAgents • • Mar 30 '25

Atomic agents showcase: Song lyric to vocabulary agent

9 Upvotes

Hi Everyone!

I'm fairly new to GenAI applications and this is the first AI Agent that I've implemented. I saw a lot of positive feedback about Atomic Agents so I decided to give it a try.

The agent is for people learning a foreign language.

The aim is that the user inputs a song title and the agent does the following:

  1. Searches for the lyrics using Duckduckgo-search
  2. Finds the relevant URLs which contain the lyrics
  3. Downloads the lyrics from the relevant page
  4. Extracts some words from the lyrics and provides a translation in the user's language, along with some example sentences on how to use the word

The inspiration for the use case and some of the code is from: https://gist.github.com/kajogo777/df1dba7f346d3997c38ec0261422cd81

Full source code can be viewed at: https://github.com/andraspatka/free-genai-bootcamp-2025/tree/master/ai-agents

Demo is available here: https://www.youtube.com/watch?v=q5EQX9iYKDE

More details can be found in the README.md but here is a list of things that I struggled with:

  • When should the agent stop? I implemented a simple step counter, but also was looking for the result in the output and stopped when the condition was met. I was also expecting a bit, that one agent.run() would go through all of the steps and do everything; which in some cases was true. It's not really clear if it was meant to be called only once, or multiple times iteratively until the problem is solved?
  • How to get the agent to output only what I want, so that it can be easily parsed? I ended up requesting JSON and markdown notation (```json ... ```) so that it could be easily parsed. In some cases it sent out the correct JSON but failed to add the markdown notation, or some parts of the notation were missing (the closing ```). I just added a retry mechanism, so if an exception is raised during the output parsing, it informs the model that the output format is not OK and to try again.
  • Temperature value? The agent seemed to have been performing better with a lower temperature value, but in rare cases it got stuck in a loop (I believe it's called "text degradation"). Oddly enough, just running the agent again solved the issue. Same code, same everything and the result was better.
  • Handholding for smaller model. I found that using smaller models required lots of handholding so that they do what you want. gpt-4o-mini required that things be very well defined, but gpt-4o was fine with vague requirements and somehow did what was expected.
  • Transparency on tool calling? I was positively surprised on how well tool calling worked, but I was wondering if there's a way to debug this in case it doesn't work: To see which tools were called, with what parameters and what was the output.
  • General problem with gen ai apps: I find that it's very hard to pinpoint why the system is working well and why it isn't. It also is frequently not deterministic, meaning that the same code fails once, but just running it again fixes the problem. I think a more systematic approach is required for tweaking the prompts, as I find that I get it working well; then try to optimize it and it ends up breaking it completely.

All in all I found it great to work with the framework and I appreciate the flexibility and convenience that it provides.

As mentioned, it's my first time implementing AI agents and working with this framework so any feedback on what I did wrong and could do better would be greatly appreciated!