In the modern era with language models being integrated into every corner of the human experience, more and more questions come up on how bets to build some of these integrations. Early on I began work on a system to allow your chat assistant to communicate with other chat assistants. The vision was simple, take the concept of a team of decision makers and translate that into a series of “agents”. Later on, the idea would go through a few different names but eventually the public would settle on “Agents as Tools”.
During these early stages, my goals were:
- Create a manageable Linux environment where all decisions made were run by this agentic system
- Make it entirely locally hosted using Ollama
After a few iterations, https://github.com/Sceptyre/bash-llm would be made public. This first release was very rudimentary. It had a lack of tool calling due to limitations of self-hosted models at the time and the simulated “tool calling” was merely trying to prompt the model to respond in a formatted manner. Here a lot was learned. The biggest being that this was very much possible and very much effective. Some other iterations were build using various other frameworks and languages shooting for the Linux LLM OS idea but none were made public.
A few months pass by and Qwen3 is released. Qwen3 appealed to the hype cycle very well. It was pretty effective, light, self-hostable, and most of all, had tool calling capabilities. This was it. I began putting together a concept utilizing the tool calling schema and Qwen3 for inference. Initial testing looked very promising but I needed more power. I purchased some credits with OpenRouter and began testing with more capable models. The self hosting still mattered, but I had to know what was possible. As I dug deeper I noticed some important things:
- Context exhaustion became less of a problem as you divided the task into smaller components and you cared only about the result
- You could create more hyper specialized Agents within a system of Agents increasing the quality of output
This was great! Others needed to be able to experience and take advantage of this. So immediately, I began work on my biggest project, my magnum opus,
https://github.com/Sceptyre/agnets-py. Agnets was a library that provided 3 main utilities, an Agnet with a tool calling loop, a vendor agnostic LLM Backend API, and a multi-agentic Fleet.
Starting with the API, a Backend was designed so any interface could be defined and be plugged straight into an Agnet. Agnets can then be
given tools utilizing some of the groundwork already laid out by the mcp python package and the mcp.server.fastmcp.tools.ToolManager.
# Create an agnet
agnet = Agent(
config=Config(
model_name="openai/openai/gpt-oss-20b",
system_prompt="""
ALWAYS use tools available to respond to your fellow agent.
Your response MUST be in a tool call.
Present to the user your answer with the `respond_to_user` tool.
"""
),
backend=OllamaBackend()
)
# Give the agnet calc tools
@agnet.add_tool
def add(a: int, b: int) -> int:
return a + b
@agnet.add_tool
def multiply(a: int, b: int) -> int:
return a * b
# Give the agnet a response tool
@agnet.add_tool
def respond_to_user(response: str):
"""
Responds to user
"""
print(response)
return True
# Ask the agent and define when to stop
agnet.invoke("What is 2*2", stop_on=['respond_to_user'])
This was great and created an easy way to expand out and begin connecting multiple of these Agnets together to create a Fleet.
The Fleet system was simple:
- Create a fleet
- Create your agents (with their tools)
- Add each agent to the fleet with a name and a list of agents it can communicate with
This created an effective way to hyperscale the agents to allow broad functionality. For example in a support type workflow, you can designate product or platform specialized agents and a “router” to communicate between all agents. Then you simply just ask the router and they can ask all relevant agents for a specific query. Each agent has its own context window and each new task between agents gets a net new context with any results from prior tasks.
Maintaining my own backends for various providers seemed like a difficult task as a solo project so eventually I moved over to making LiteLLM the preferred backend for all Agnets. This allowed taking advantage of the full spread of vendors while also providing a value that was still a slight shortcoming in most agentic frameworks available.
Well, this was a very fun adventure and I learned alot about specifically Agent prompting, contexts, and tool calling however as of today, I’ve been made aware that https://strandsagents.com/latest/documentation/docs/user-guide/concepts/multi-agent/swarm/ exists and does a really good job of meeting most, if not all, of the functionality in Agnets Fleets. Unless anything new is discovered and there is a reason to maintain or expand on Agnets, go check out https://strandsagents.com and give them some support. And, if you’ve not messed around with LLM tool calling or MCP servers, do it!
– Oblongata