Agentic Framework on Producthunt daily

elysia

Fri, 05 Sep 2025 15:28:11 +0800

weaviate/elysia

Elysia: Agentic Framework Powered by Decision Trees

⚠️ Elysia is in beta!

If you encounter any issues, please open an issue on GitHub.

Elysia is an agentic platform designed to use tools in a decision tree. A decision agent decides which tools to use dynamically based on its environment and context. You can use custom tools or use the pre-built tools designed to retrieve your data in a Weaviate cluster.

Read the docs!

Installation is as simple as:

`1`	`pip install elysia-ai`

Get started (App)

Run the app via

`1`	`elysia start`

Then navigate to the settings page, add your required API keys, Weaviate cloud cluster details and specify your models.

Don’t forget to check out the Github Repository for the Frontend!

Alternatively, we have created a demo version of Elysia (rate-limited, fixed datasets) to experiment with. Find it at: https://elysia.weaviate.io/

Get Started (Python)

To use Elysia, you need to either set up your models and API keys in your .env file, or specify them in the config. See the setup page to get started.

Elysia can be used very simply:

from elysia import tool, Tree

tree = Tree()

@tool(tree=tree)
async def add(x: int, y: int) -> int:
    return x + y

tree("What is the sum of 9009 and 6006?")

Elysia is pre-configured to be capable of connecting to and interacting with your Weaviate clusters!

import elysia
tree = elysia.Tree()
response, objects = tree(
    "What are the 10 most expensive items in the Ecommerce collection?",
    collection_names = ["Ecommerce"]
)

This will use the built-in open source query tool or aggregate tool to interact with your Weaviate collections. To get started connecting to Weaviate, see the setting up page in the docs.

Installation (bash) (Linux/MacOS)

PyPi (Recommended)

Elysia requires Python 3.12:

Optionally create a virtual environment via

1
2

python3.12 -m venv .venv
source .venv/bin/activate

Then simply run

`1`	`pip install elysia-ai`

to install straight away!

GitHub

To get the latest development version, you can clone the github repo by running

`1`	`git clone https://github.com/weaviate/elysia`

move to the working directory via

`1`	`cd elysia`

Create a virtual environment with Python (version 3.10 - 3.12)

1
2

python3.12 -m venv .venv
source .venv/bin/activate

and then install Elysia via pip

`1`	`pip install -e .`

Done! You can now use the Elysia python package

Configuring Settings

To use Elysia with Weaviate, i.e. for agentic searching and retrieval, you need a Weaviate cluster api key and URL. This can be specific in the app directly, or by creating a .env file with

1
2

WCD_URL=...
WCD_API_KEY=...

Elysia will automatically detect these when running locally, and this will be the default Weaviate cluster for all users logging into the Elysia app. But these can be configured on a user-by-user basis through the config.

Whichever vectoriser you use for your Weaviate collection you will need to specify your corresponding API key, e.g.

`1`	`OPENAI_API_KEY=...`

These will automatically be added to the headers for the Weaviate client.

Same for whichever model you choose for the LLM in Elysia, so if you are using GPT-4o, for example, specify an OPENAI_API_KEY.

Elysia’s recommended config is to use OpenRouter to give easy access to a variety of models. So this requires

`1`	`OPENROUTER_API_KEY=...`

FAQ

How do I use Elysia with my own data?

You can connect to your own Weaviate cloud cluster, which will automatically identify any collections that exist in the cluster.

Collections require being preprocessed for Elysia. In the app, you just click the ‘analyze’ button in the Data tab. In Python you can do:

1
2
3

from elysia.preprocessing.collection import preprocess

preprocess(collection_names=["YourCollectionName"])

Can I use a locally running version of Weaviate such as with Docker?

Locally running versions of Weaviate are currently not implemented in the current version of the app but this is planned for a future release. Stay tuned!

How do I clear all my Elysia data?

Everything Elysia doesn’t store locally will be a collection in your Weaviate cluster. You can delete any collections that start with ELYSIA_ to reset all your Elysia data.

For example, in Python:

from elysia.util.client import ClientManager()
with ClientManager().connect_to_client() as client:
    for collection_name in client.collections.list_all():
        if collection_name.startswith("ELYSIA_"):
            client.collections.delete(collection_name)

Can I contribute to Elysia?

Elysia is fully open source, so yes of course you can! Clone and create a new branch of Elysia via

1
2

git clone https://github.com/weaviate/elysia
git checkout -b <branch_name>

Make your changes, push them to your branch, go to GitHub and submit a pull request.

Where is the best place I can start contributing?

There are no ‘huge’ new features we are planning for Elysia (for the moment). You could start with creating a new tool, or multiple new tools to create a custom workflow for something specific. Look for pain points you experience from your user journey and find what exactly is causing these. Then try to fix them or create an alternative way of doing things!

agent-zero

Fri, 06 Jun 2025 15:28:05 +0800

frdel/agent-zero

`Agent Zero`

Introduction • Installation • Hacking Edition • How to update • Documentation • Usage

A personal, organic agentic framework that grows and learns with you

Agent Zero is not a predefined agentic framework. It is designed to be dynamic, organically growing, and learning as you use it.
Agent Zero is fully transparent, readable, comprehensible, customizable, and interactive.
Agent Zero uses the computer as a tool to accomplish its (your) tasks.

💡 Key Features

General-purpose Assistant

Agent Zero is not pre-programmed for specific tasks (but can be). It is meant to be a general-purpose personal assistant. Give it a task, and it will gather information, execute commands and code, cooperate with other agent instances, and do its best to accomplish it.
It has a persistent memory, allowing it to memorize previous solutions, code, facts, instructions, etc., to solve tasks faster and more reliably in the future.

Computer as a Tool

Agent Zero uses the operating system as a tool to accomplish its tasks. It has no single-purpose tools pre-programmed. Instead, it can write its own code and use the terminal to create and use its own tools as needed.
The only default tools in its arsenal are online search, memory features, communication (with the user and other agents), and code/terminal execution. Everything else is created by the agent itself or can be extended by the user.
Tool usage functionality has been developed from scratch to be the most compatible and reliable, even with very small models.
Default Tools: Agent Zero includes tools like knowledge, webpage content, code execution, and communication.
Creating Custom Tools: Extend Agent Zero’s functionality by creating your own custom tools.
Instruments: Instruments are a new type of tool that allow you to create custom functions and procedures that can be called by Agent Zero.

Multi-agent Cooperation

Every agent has a superior agent giving it tasks and instructions. Every agent then reports back to its superior.
In the case of the first agent in the chain (Agent 0), the superior is the human user; the agent sees no difference.
Every agent can create its subordinate agent to help break down and solve subtasks. This helps all agents keep their context clean and focused.

Completely Customizable and Extensible

Almost nothing in this framework is hard-coded. Nothing is hidden. Everything can be extended or changed by the user.
The whole behavior is defined by a system prompt in the prompts/default/agent.system.md file. Change this prompt and change the framework dramatically.
The framework does not guide or limit the agent in any way. There are no hard-coded rails that agents have to follow.
Every prompt, every small message template sent to the agent in its communication loop can be found in the prompts/ folder and changed.
Every default tool can be found in the python/tools/ folder and changed or copied to create new predefined tools.

Communication is Key

Give your agent a proper system prompt and instructions, and it can do miracles.
Agents can communicate with their superiors and subordinates, asking questions, giving instructions, and providing guidance. Instruct your agents in the system prompt on how to communicate effectively.
The terminal interface is real-time streamed and interactive. You can stop and intervene at any point. If you see your agent heading in the wrong direction, just stop and tell it right away.
There is a lot of freedom in this framework. You can instruct your agents to regularly report back to superiors asking for permission to continue. You can instruct them to use point-scoring systems when deciding when to delegate subtasks. Superiors can double-check subordinates’ results and dispute. The possibilities are endless.

🚀 Things you can build with Agent Zero

Development Projects - "Create a React dashboard with real-time data visualization"
Data Analysis - "Analyze last quarter's NVIDIA sales data and create trend reports"
Content Creation - "Write a technical blog post about microservices"
System Admin - "Set up a monitoring system for our web servers"
Research - "Gather and summarize five recent AI papers about CoT prompting"

Hacking Edition

Agent Zero also offers a Hacking Edition based on Kali linux with modified prompts for cybersecurity tasks
The setup is the same as the regular version, just use the frdel/agent-zero-run:hacking image instead of frdel/agent-zero-run

⚙️ Installation

Click to open a video to learn how to install Agent Zero:

A detailed setup guide for Windows, macOS, and Linux with a video can be found in the Agent Zero Documentation at this page.

⚡ Quick Start

# Pull and run with Docker

docker pull frdel/agent-zero-run
docker run -p 50001:80 frdel/agent-zero-run

# Visit http://localhost:50001 to start

🐳 Fully Dockerized, with Speech-to-Text and TTS

Customizable settings allow users to tailor the agent’s behavior and responses to their needs.
The Web UI output is very clean, fluid, colorful, readable, and interactive; nothing is hidden.
You can load or save chats directly within the Web UI.
The same output you see in the terminal is automatically saved to an HTML file in logs/ folder for every session.

Agent output is streamed in real-time, allowing users to read along and intervene at any time.
No coding is required; only prompting and communication skills are necessary.
With a solid system prompt, the framework is reliable even with small models, including precise tool usage.

👀 Keep in Mind

Agent Zero Can Be Dangerous!

With proper instruction, Agent Zero is capable of many things, even potentially dangerous actions concerning your computer, data, or accounts. Always run Agent Zero in an isolated environment (like Docker) and be careful what you wish for.

Agent Zero Is Prompt-based.

The whole framework is guided by the prompts/ folder. Agent guidelines, tool instructions, messages, utility AI functions, it’s all there.

📚 Read the Documentation

Page	Description
Installation	Installation, setup and configuration
Usage	Basic and advanced usage
Architecture	System design and components
Contributing	How to contribute
Troubleshooting	Common issues and their solutions