agentify-core 0.2.0

Framework-agnostic AI agent library for building single and multi-agent systems

Agentify

Independent AI agent library based on the OpenAI SDK

Agentify is a Python library for building and orchestrating AI agents, from simple assistants to complex multi-agent systems. It targets the OpenAI-compatible Chat Completions interface, enabling support for multiple providers through a configurable base_url (OpenAI, Azure OpenAI, DeepSeek, Gemini, etc.). Agentify offers a streamlined, independent set of primitives for memory, tools, and coordination so you can focus on product logic without being tied to heavy frameworks.

Why Agentify?

• Built for production: clear abstractions, explicit configuration, error handling and extension points that map well to real deployments.
• Orchestration-first design: a uniform run() interface for agents, teams, pipelines and hierarchies makes it straightforward to compose and refactor flows.
• Providers: switch between OpenAI, Gemini, Azure OpenAI, DeepSeek, Claude and others without changing your agent code.

Key Features

• Agents and multi-agent patterns
  Single Agents with tools and memory, supervisor–worker Multi-Agent Teams, Sequential Pipelines where output flows from step to step, Hierarchical Structures for complex delegation, and Dynamic Flows where a controller decides at runtime which sub-agents or teams to invoke.

• Memory service and isolation
  Pluggable backends (in-memory, Redis, …) with per-use-case policies (TTL, maximum messages, etc.), plus optional memory isolation so each agent can maintain its own conversation history for scalability and privacy.

• Reasoning Models
  Configure the model's thinking depth, safely merge model_kwargs, automatically store "Chain of Thought" in conversation history, and log reasoning steps in real-time for visibility.

• Tools and actions
  Simple @tool decorator for creating tools from functions with automatic JSON Schema generation, or type-annotated tool interface for custom implementations.

• Observability hooks
  Callback system for logging, monitoring and debugging agent behaviour across complex flows.

• I/O capabilities
  Streaming support for real-time responses and vision/image models for multimodal interactions.

• Async & Parallel Execution
  Built-in async/await support (arun()) for all agents and flows. Automatically executes independent tool calls in parallel (e.g., fetching data from 3 APIs simultaneously), significantly reducing latency.

Installation

pip install agentify-core

For optional features:

pip install agentify-core[all]  # Installs all optional dependencies

Quick Start

from agentify import BaseAgent, AgentConfig, MemoryService, MemoryAddress, tool
from agentify.memory.stores import InMemoryStore

# 1. Create a simple tool with @tool decorator
@tool
def get_time() -> dict:
    """Returns the current time."""
    from datetime import datetime
    return {"time": datetime.now().strftime("%H:%M:%S")}

# 2. Create memory service
memory = MemoryService(store=InMemoryStore(), log_enabled=True, max_log_length=100)
addr = MemoryAddress(conversation_id="session_1")

# 3. Create an Agent with the tool
agent = BaseAgent(
    config=AgentConfig(
        name="ReasoningAgent",
        system_prompt="You are a helpful assistant.",
        provider="provider",
        model_name="model",
        reasoning_effort="high",  # optional param:"low", "medium", "high"
        model_kwargs={"max_completion_tokens": 5000} # Pass model-specific params
    ),
    memory=memory,
    memory_address=addr,
    tools=[get_time]  # Add your tools here
)

# 4. Run a conversation
response = agent.run(user_input="What time is it?")

Composable Flows

Agentify provides powerful primitives that can be combined to build arbitrarily complex systems:

• BaseAgent: The fundamental unit of work.
• Teams: A group of agents managed by a supervisor.
• Pipelines: A sequence of steps where output passes from one to the next.
• Hierarchies: Tree structures for massive delegation.

Because all flows share the same run() interface, you can build Teams made of Pipelines, Pipelines made of Teams, and deeply nested Hierarchies.

Agentify supports both strict workflows (fixed, pre-defined Pipelines and Hierarchies) and dynamic agentic flows, where a supervisor/router agent decides at runtime which agent, Team or Pipeline to call next.

Learn More

For detailed documentation, examples, and API reference, visit the GitHub repository.

Contributing

Contributions are welcome! Please visit the repository to report issues or submit pull requests.

License

MIT License - see the repository for details.

Author

Fabian Melchor - [e-mail]