Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Agented - is a modular open-source framework for developing AI agents with hierarchical structure and ability to integrate functions and agents. It features a functions marketplace that enables easy expansion of agent capabilities and the creation of complex, scalable AI systems, forming a complete ecosystem.
Key advantages:
Modularity: You can leverage Agent Core as a foundational building block and easily extend its capabilities by adding functions or even incorporating other agents.
Hierarchical structure: Supports parent-child AI agents relationships to create complex multi-agent systems.
No-code solutions supported: Dashboard to Create AI Agents without Coding - .
: Provides access to ready-made functions to extend agent capabilities and monetize your own developments.
Extensibility: Offers the ability to add custom functions and integrate with external services.
Functions Marketplace is a platform for sharing and monetizing modular functions for AI agents. Functions Marketplace allows for expanding agent capabilities by integrating pre-built functions such as data retrieval, API requests, and other useful operations.
Functionality:
Catalog: A library of ready-made functions categorized for easy browsing.
Publishing: The ability for developers to publish their functions and make them available to other users.
Monetization: Monetization mechanisms for function developers (subscription, pay-per-use).
Integration in Agent Builder: A user-friendly way to add functions from the marketplace to agents created through Agent Builder.
Integration via Core Library: The option to programmatically connect functions from the marketplace through the Core Library.
Secure Testing: Utilizing the vm2 sandbox for the safe execution of marketplace functions.
Updates via Smart Contracts: A mechanism for updating functions and their terms of use through on-chain smart contracts, ensuring transparency and fair monetization.
Applications:
Extending agent functionality without needing to develop everything from scratch.
Utilizing pre-built integrations with various APIs and services.
Monetizing your own function developments for AI agents.
Creating a community of developers and function providers for the AI Agent Framework ecosystem.
AgentCore Library is a lightweight JavaScript library that provides the fundamental building blocks for creating AI agents. The library is available on GitHub and empowers developers with full control over the code, data, and API keys.
Agent Creation: Initialization of agents with diverse configurations, prompts, functions, and child agents.
Agent Behavior Management: Configuration of prompts, functions, reflections, and other parameters to define agent behavior.
Function Integration: Connecting custom user-defined functions and functions from the Functions Marketplace.
Hierarchical Agent Management: Creation of parent and child agents, managing their interaction.
Reflection Support: Configuration of automated reflections for agent self-monitoring and improvement.
Asynchronous Requests: Execution of asynchronous operations to enhance performance.
Event Handling: Implementation of an event-driven model for inter-agent communication.
Applications:
Development of custom agents with unique business logic.
Creation of complex multi-agent systems.
Integration into existing applications and services.
Community: 90% of the total token supply is allocated to the community ΠΈ will be available from the token launch.
Team: 5% of the total token supply is reserved for the project team. These tokens will be subject to a 12-month lock-up period, followed by monthly vesting in equal parts.
Treasury: 5% of the total token supply is allocated to the project treasury. The distribution of funds from the treasury will be carried out quarterly in the form of grants and rewards for the most active community members and developers contributing to the project's growth.
Buyback Mechanism: The marketplace will direct 50% of the commissions generated from the use of platform features to buyback AGNT tokens from the market. This will create constant demand for the token and potentially support its price. The remaining 50% of commissions will be directed to the treasury to ensure operational activities and further project development. Decentralized
Autonomous Organization (DAO): In the future, a Decentralized Autonomous Organization (DAO) will be launched to govern the project. AGNT token holders will have the opportunity to participate in voting and decision-making regarding the future development of the platform. To ensure effective governance and prevent manipulation, voting rights will be granted to users holding more than 1kk AGNT tokens.
Launch of no-code Agent Builder module: Introduction of a tool for creating AI agents without programming.
Integration of the first 20 functions into Marketplace: Filling the marketplace with an initial set of functions for creating diverse agents.
Development of showcase AI agents: Creation of demonstration agents that clearly show the capabilities of the platform and library.
Project token launch: Introduction of the token into the Agented economy.
Opening of the Marketplace for third-party functions (without monetization): Opportunity for developers to add their functions for testing and expanding the catalog.
Open-source Core Library on GitHub: Publication of the library with open source code for free use and creation of agents outside the platform.
Launch of DAO and voting: Creation of a decentralized governance system to involve the community in project development.
Conducting hackathons for developers: Organization of competitions and events to stimulate the creation of AI products based on the library.
Launch of AGNT buybacks: Implementation of a token buyback mechanism from marketplace commissions to support the token economy.
Launch of Marketplace economy with monetization: Opening opportunities for developers to sell their agents and functions with various monetization models (subscription, pay-per-use).
Instructions on how to create an agent using Agent Builder will be added in future documentation versions
Functions Marketplace allows users to create, publish, and integrate functions into their agents.
The first step is to develop the function itself. The function can perform a wide variety of actions, ranging from retrieving data from external sources, such as websites or databases, to processing and analyzing information, generating content, or executing specific commands.
Once the function has been developed and tested, the next step is to publish it on the marketplace. To do this, you need to go to the Functions Marketplace section and fill out a form, providing information about the function β category selection, name, description, input parameters, data return format, and more. The developer can choose to make the function available by subscription or use a pay-per-use model.
Functions can interact with any external services and data sources using HTTP/HTTPS requests for web services, RPC for calling remote procedures, integrate with databases, or work with the file system. Developers can embed their own keys in the function or provide the ability to enter user API keys.
In Agent Builder, a visual interface, adding a function from the marketplace is as simple as navigating to the relevant section, selecting the option to add from the Marketplace, and, if necessary, configuring parameters, including user API keys.
Developers can create functions that integrate APIs or implement algorithms, as well as develop solutions that simplify integration with popular services. Data providers can provide access to their data by providing it through convenient functions and offering users a model without the need to manage API keys.
The Functions Marketplace commission is 10% of the revenue, which ensures transparent conditions and allows supporting the development of the platform.
Agented framework is a lightweight, modular library for building AI agents with full control over data flows and integrations.
Agents are structured as a hierarchical decision-making system, organized in a tree-like structure, ensuring modularity and clear separation of responsibilities between components. Agents operate within a parent-child framework, where lower-level agents report to their superiors. They can delegate tasks to child agents or invoke functions and inherit access to tools and functions from their parent chain.
The Agent can be configured using:
Agent Config: Settings that define the properties of the agent (name, description, type, etc.).
Prompts: Textual instructions that control the agent's behavior and provide context for its actions.
API Keys: Authentication credentials for accessing external services via APIs.
The Agent Core is the central processing unit of an agent, responsible for its core logic and functionality. The agent core can be configured using:
Agent Input Preparation: Component responsible for processing and formatting input data for the agent.
Steps Manager: Coordinates the sequence of task execution by the agent, defining the order of actions.
Decider: Component that makes decisions about request routing and further actions based on the agent's logic.
The Reflection System empowers AI agents with automated self-monitoring capabilities, enabling them to assess and adapt their performance proactively. Key Components:
Reflection Prompt:
Defines the specific instructions and criteria that guide the agent's self-assessment process.
Determines the behavior and focus of the agent during reflection.
Reflection Schedule:
Function Management is responsible for overseeing and providing the executable capabilities that AI agents use to perform diverse tasks. Key Components:
Functions:
Represent the core executable capabilities available to agents. Each function is designed to perform a particular task. Encompass a range of operations, from simple computations to complex interactions.
Asynchronous Retrieval Augmented Generation (async RAG):
Enables agents to asynchronously retrieve and utilize relevant information from external sources.
Augments the agent's knowledge and decision-making capabilities with up-to-date data.
Children Agents facilitate a hierarchical structure within the system, enabling the delegation of specialized tasks and promoting efficient, scalable operations. Key Features:
Hierarchical Organization:
Agents are structured in a parent-child relationship, forming a hierarchical tree. This allows for the creation of complex agent networks.
Lower-level agents report their status and results upward to their parent agents. This framework ensures organized and scalable agent interactions.
Subordinate Agents (Children Agents):
Operational Context is a storage used to maintain the current state and context of agents. This includes:
Recent interactions, data processed, and decisions made.
Stored knowledge, learned patterns, and accumulated experience.
The Operational context allows the AI agent to keep track of what it has already done, and to take the next steps based on that.
Provides communication and integration between various system components.
Event Bus, I/O: Communication infrastructure for handling events and I/O operations, allowing components to interact asynchronously and efficiently.
The library supports Asynchronous Requests, enabling agents to handle multiple operations simultaneously without waiting for each task to complete before starting the next. This capability is crucial for:
Performance Optimization: Enhance the responsiveness and throughput of agents by utilizing non-blocking operations.
Concurrency Management: Efficiently manage multiple tasks, especially when dealing with I/O-bound or long-running operations.
Error Handling: Implement robust error handling mechanisms to gracefully manage failures in asynchronous tasks without disrupting the entire agent workflow.
Agents can emit and listen to events, facilitating seamless communication within the agent hierarchy. This feature allows agents to:
React to Changes: Automatically respond to specific events or triggers, ensuring dynamic and adaptive behavior.
Coordinate Tasks: Synchronize actions between parent and child agents, promoting cohesive and organized operations.
Handle Errors: Propagate error states upwards, enabling parent agents to manage and mitigate issues effectively.
Agents are equipped with mechanisms for resource management and cleanup, ensuring the efficient use of system resources and preventing memory leaks or dangling processes. Key aspects include:
Timeouts and Intervals: Automatically manage timing-based operations to prevent tasks from running indefinitely.
Cleanup Procedures: Clear timeouts, intervals, and event listeners upon agent termination or error states, maintaining system integrity.
Retry Logic: Implement retry mechanisms for failed tasks, enhancing reliability and resilience in operations.
The library is designed for extensibility and customization, allowing developers to tailor agents to specific needs. Features include:
Custom Prompts: Define unique prompts and instructions for each agent to guide their behavior and responses.
Function Injection: Assign custom functions to agents, extending their capabilities and enabling specialized tasks.
Mixin Integration: Incorporate mixins to add additional context or functionality, promoting code reuse and modularity.
Agents can integrate with marketplace services, leveraging external functionalities and services to enhance their operations. This includes:
Marketplace Functions: Utilize predefined or custom marketplace functions to perform specialized tasks.
Sandbox Environment: Execute marketplace functions within a secure sandbox to ensure safe and controlled operations.
Dynamic Function Loading: Dynamically load and update functions from the marketplace, ensuring agents can adapt to new requirements without redeployment.
This architecture demonstrates a modular, hierarchical agent system with secure function execution, event-driven communication, and marketplace integration. The design allows for complex agent networks with parent-child relationships, scheduled reflections, and extensible function capabilities.
Configures the frequency and timing of reflection activities using cron schedules.
Ensures periodic self-analysis, enabling agents to stay up-to-date and responsive.
Automated Reflection Process:
Reflections are triggered automatically based on the defined schedule.
The system generates input signals based on the agent's current state and available methods.
This allows agents to:
Perform routine checks and diagnostics.
Update internal states and knowledge.
Execute maintenance tasks.
Adapt to changing environment's.
The automated nature of reflections minimizes the need for manual intervention, promoting continuous improvement and adaptability.
User-defined functions tailored to specific agent requirements. Allow agents to perform a wide variety of operations, including:
Database Queries: Interact with databases to retrieve, update, or delete data.
API Calls: Communicate with external APIs to fetch or send information.
File Operations: Read, write, and manipulate files within the system.
Asynchronous Operations: Execute tasks concurrently to enhance performance and responsiveness.
Children agents are subordinate agents within the hierarchy. They are assigned specific, specialized tasks by their parent agents.
Children agents maintain separation of concerns. This reduces complexity and potential conflicts between operational areas.
Sub-agents can be easily added or removed to adjust to changing workloads or requirements.
Sub-agents focus on specific domains or functions. This enhances efficiency and expertise.
Explore the vast Function Marketplace directly from the Main Chat! Our integrated agent can access and utilize every function on the Marketplace. To get started, connect your wallet and type your request in the chat. Need help discovering what's possible? Just ask β this agent will be your personal guide to all features and functionalities.
Agent Builder is an intuitive dashboard for constructing AI agents without writing code. Agent Builder allows you to visually configure agents, connect functions, define interactions, and deploy them efficiently.
Functionality:
Visual Agent Creation: Creating and configuring agents through a graphical user interface.
Function Integration: Adding functions to agents from the Functions Marketplace and user-defined custom functions.
Agent Prompt and Parameter Configuration: Managing agent configurations through a user-friendly interface.
Hierarchical Agent Creation: Visually building parent-child relationships between agents.
Agent Deployment: Efficient deployment of created agents.
Support for asynchronous requests and embedded databases.
Support for self-learning loops.
Applications:
Rapid creation and prototyping of agents without the need for programming.
Usable for business users without technical skills.
Creating simple agents for performing routine tasks.
Visualization and management of complex multi-agent systems.
Interface (Expected): Screenshots of the Agent Builder interface will be added in future documentation versions.
At Agented, we see our goal in creating an ecosystem where AI agents can truly develop and thrive.
The recent launch of Claude 3 and the evolution of AI platforms in general confirm that the future lies in complex, interconnected AI systems. However, there is still a significant gap between the emergence of powerful AI models and their real-world application in everyday tasks.
Agented is designed to bridge this gap in three key areas:
Firstly, Agented implements a hierarchical agent structure that reflects the principles of real-world organizations. In our framework, agents can delegate tasks, interact with each other, and learn from experience β just like people do in a team.
Secondly, we are creating a digital economy for AI functions. We are building a where developers can publish and monetize their AI agents and functions. Imagine an "App Store for AI capabilities" β a platform where any function can be integrated into existing systems, expanding their potential.
Thirdly, Agented is designed to support both code and no-code solutions with , making AI agent development accessible to a wide range of users, regardless of their technical skills.
Agented offers:
A unified platform for interaction between developers and users of AI agents and functions.
Ready-made infrastructure for launching agents.
A transparent and understandable monetization system for creators of functions and agents.
A Marketplace with a wide selection of ready-made AI solutions and components.
Agented builds a ecosystem for AI agents, integrating a hierarchical structure, function marketplace, and no-code tools. This empowers developers and businesses to collaboratively create, practically implement, and monetize AI solutions, making the power of AI models accessible to everyone.
Creating a simple research agent with a search function (vectorSearch).
Creating a multi-agent system with a parent agent (editorAgent) and child agents (fact-checker, style-enforcer) for content editing tasks.
Example of an agent with a self-reflection function (selfReflectingAgent) that periodically analyzes its own performance.
Creating a personal assistant agent (personalAssistant) with functions for calendar management, sending emails, and child agents for meeting preparation and travel planning.
Example of a tech support agent (supportBot) with knowledge base search functions, ticket creation capabilities, and a child agent for log analysis. It also includes reflection for knowledge base updates.
Creating a news analysis agent (newsAnalyzer) with functions for news retrieval, sentiment analysis, a child agent for trend detection, and reflection for generating daily reports.
const researchAgent = new AgentCore({
name: 'research-bot',
prompt: 'Analyze technical documents...',
functions: [{
func: vectorSearch,
name: 'document_search',
description: 'Search knowledge base',
paramsToPass: {
query: 'string'
}
}]
});const editorAgent = new AgentCore({
name: 'content-editor',
children: [{
name: 'fact-checker',
prompt: 'Verify factual accuracy...',
functions: [webSearchTool]
},
{
name: 'style-enforcer',
prompt: 'Ensure AP Style guidelines...'
}
]
});const personalAssistant = new AgentCore({
name: 'main-assistant',
prompt: `Manage user's schedule and communications`,
functions: [{
func: checkCalendar,
name: 'check_calendar',
description: 'Access Google Calendar'
},
{
func: sendEmail,
name: 'send_email',
description: 'Send messages via Gmail'
}
],
children: [{
type: EAgentType.WORKER,
name: 'meeting-preparer',
prompt: `Prepare documents for upcoming meetings`,
functions: [generateMeetingBrief]
},
{
type: EAgentType.WORKER,
name: 'travel-planner',
prompt: `Handle travel arrangements`,
functions: [bookFlights, reserveHotels]
}
]
});const supportBot = new AgentCore({
name: 'tech-support',
prompt: `Handle technical support queries`,
functions: [{
func: searchKnowledgeBase,
name: 'search_kb',
description: 'Query internal documentation'
},
{
func: createTicket,
name: 'create_ticket',
description: 'Generate Jira ticket'
}
],
children: [{
type: EAgentType.WORKER,
name: 'debug-helper',
prompt: `Analyze error logs and suggest solutions`,
functions: [parseLogs]
}],
reflections: [{
type: EAgentType.REFLECTION,
name: 'knowledge-update',
prompt: `Identify gaps in knowledge base`,
cronSchedule: '0 0 * * 1' // Weekly on Mondays
}]
});const newsAnalyzer = new AgentCore({
type: EAgentType.PERMANENT,
name: 'news-analyst',
prompt: `Analyze financial news and identify market trends`,
functions: [{
func: fetchNewsAPI, // Local function
name: 'get_latest_news',
description: 'Fetch news from configured sources',
params: {
category: 'finance'
}
},
{
func: marketplaceSentimentAnalysis, // Marketplace function
name: 'sentiment_analysis',
description: 'Advanced NLP analysis (paid)',
}
],
children: [{
type: EAgentType.WORKER,
name: 'trend-spotter',
prompt: `Identify emerging trends in news articles`,
functions: [calculateTrendScore]
}],
reflections: [{
type: EAgentType.REFLECTION,
name: 'daily-summary',
prompt: `Generate market summary report`,
cronSchedule: '0 0 18 * * *' // 6PM daily
}]
});Developers who are looking for AI solutions for their applications or services can use the framework to build their own agent without much effort using the , and .
For agent and function developers, Agented provides a powerful platform with a wide range of opportunities for creativity, and monetization. Developers can use Agented to create a variety of agents and reusable functions that can perform specific tasks (API requests, data processing, interaction with external services, etc.) and publish them on
Data providers are organizations or individuals who own valuable datasets and are willing to provide access to this data for use in AI agents. This can be any information that can be used to train, inform, or operate AI agents. Examples:
Real-time financial data: Stock quotes, cryptocurrencies, market trend data.
Historical data: Archived weather data, economic indicators for past periods.
Specialized knowledge bases: Data on specific industries, scientific fields, legal databases, etc.
API access: The provider can provide access to their API, through which agents can receive data (for example, API for geolocation, API for social media analysis, etc.).
For business users who are not developers and don't work with code, Agented becomes accessible and powerful through the β an intuitive no-code module. Agent Builder allows you to create and configure intelligent agents using a visual interface, completely eliminating the need for programming.