I have been building AI agents for quite some time now. The shift has gone from LLM + Tools → LLM Workflows → Agent + Tools + Memory, and now we are finally seeing true agency emerge: agents as systems composed of tools, command-line access, fine-grained system capabilities, and memory.

This way of building agents is powerful, and I believe it is here to stay. But the real question is: are the systems powering these agents ready for that future?

I do not think so.

Using Docker for a single agent is not going to scale well, because agents need to be lightweight and fast. LLMs already add significant latency, so adding heavy runtime overhead on top only makes things worse. Existing solutions start to fall apart here.

Agents built in Python also tend to have a large memory footprint, which becomes a serious problem when you want to scale to thousands of agents.

And open-source for agents is still not where it should be. Right now, I cannot easily reuse agents built by domain experts the same way I reuse open-source software.

These issues bothered me, and I realized that if agents are ever going to be democratized, they need to be open and easy to use. Just like Docker solved system dependencies, we need something similar for agents.

That is why I started building an agent framework in Rust. It is modular and follows the principle of true agency: an agent is an entity with tools, memory, and an executor. In AutoAgents, users can independently create and modify tools, executors, and memory.

With AutoAgents, I saw that powerful agents could be built without compromising on performance or memory the way many other frameworks do.

But the other problems still remained: re-sharing agents, sandboxing, and scaling to thousands of agents.

So I created Odyssey — a bundle-first agent runtime written in Rust on top of AutoAgents, the Rust agent framework. It lets you define an agent once, package it as a portable artifact, and run it through the same execution model across local development, embedded SDK usage, shared runtime servers, and terminal workflows.

Both AutoAgents and Odyssey are fully open source and built in Rust, and I am planning to build an Odyssey Agent Hub soon, with additional features like WASM tools, custom memory layers, and more.

My vision is to democratize agents so they are available to everyone — securely and performantly. Being open is not enough; agents also need to be secure.

The project is still in alpha, but it is in a working state.

AutoAgents Repo -> https://github.com/liquidos-ai/AutoAgents

Odyssey Repo -> https://github.com/liquidos-ai/Odyssey

I would really appreciate feedback — especially from anyone who has dealt with similar problems. Your feedback help me shape the product.

Thanks for your time in advance!