AgenticAI — Phase 2 Framework

A Deterministic, Modular Agentic Execution Engine

AgenticAI is a lightweight Python framework for building deterministic, multi-step agentic workflows. Phase 2 transforms the project from a simple step extractor into a real execution engine with planning, tool orchestration, context passing, and a fully validated test suite.

This repository contains the core framework only. A separate repository (AgenticAI-App) demonstrates how to build applications on top of this framework.

Why Phase 2 Exists:
Phase 2 establishes a stable, deterministic execution engine that Phase 3 will extend with LLM‑powered planning, memory, and richer workflows.

Companion Application:
A full demonstration of this framework in action is available in the companion repository:
https://github.com/BlodgettDavid/AgenticAI-App

---

Phase 2 Overview

Phase 2 focuses on correctness, determinism, and architectural clarity. It intentionally removes all LLMs, memory systems, orchestration layers, and high-level agents from earlier iterations. What remains is a clean, testable, fully deterministic agentic pipeline:

1. PlanningAgent — extracts steps from natural language (string-based)
2. WorkflowAgent — executes steps with sequencing, parallelism, and context passing
3. Deterministic Tools — search, summarize, define, calculator
4. Full test suite — integration, regression, negative, and unit tests

Phase 2 is the foundation for Phase 3, where LLMs, memory, and richer planning will be reintroduced on top of this stable core.

---

Key Features (Phase 2)

• Deterministic step extraction (string-based)
• Workflow execution engine with:
  • sequential execution
  • parallel execution
  • dependency ordering
  • conditional execution
  • repeat-until loops
  • refinement loops
  • context propagation (last_result)
• Modular tool system (search, summarize, define, calculator)
• No LLMs, no memory, no embeddings
• Fully passing test suite across integration, regression, negative, and unit tests
• Clean, minimal architecture designed for teaching and extension

---

Project Structure (Phase 2)

agenticai/
    __init__.py
    planning/
        planning_agent.py
        plan.py
    tools/
        base_tool.py
        definition_tool.py
        summarizer_tool.py
        search_tool.py
        calculator_tool.py
    workflow/
        workflow_agent.py

tests/
    integration/
    regression/
    negative/
    unit/

LICENSE
README.md
pyproject.toml

All unused modules from earlier iterations (memory, LLM client, orchestration, ResearchAgent, utils, old docs, old tests) have been intentionally removed.

---

Installation (Development Mode)

pip install -e .

This installs the framework in editable mode so changes take effect immediately.

---

Basic Usage Example

Below is a minimal example showing how to run a plan through the WorkflowAgent using the built-in deterministic tools.

from agenticai.planning.planning_agent import PlanningAgent
from agenticai.workflow.workflow_agent import WorkflowAgent
from agenticai.tools.search_tool import SearchTool
from agenticai.tools.summarizer_tool import SummarizerTool
from agenticai.tools.definition_tool import DefinitionTool
from agenticai.tools.calculator_tool import CalculatorTool

tools = {
    "search": SearchTool(),
    "summarizer": SummarizerTool(),
    "define": DefinitionTool(),
    "calculator": CalculatorTool(),
}

planner = PlanningAgent()
workflow = WorkflowAgent(tools=tools)

plan = planner.extract_steps("search quantum computing, then summarize it")
result = workflow.execute(plan)

print(result)

Note: In Phase 2, the planner does not yet support multi-step natural language chaining (“then summarize it”).
That capability is part of Phase 3.
Explicit step definitions work as expected.

---

Design Philosophy

1. Deterministic

Phase 2 avoids LLMs entirely to ensure reproducibility and clarity.

2. Modular

Planning, tools, and workflow execution are cleanly separated.

3. Transparent

No hidden magic. All logic is explicit and inspectable.

4. Extensible

Phase 3 will layer LLMs, memory, and richer planning on top of this stable core.

---

Phase 2 Limitations (Intentional)

These are not bugs — they are design choices for Phase 2:

• Planner does not support multi-step natural language (“then summarize it”)
• No LLM-based summarization
• No memory retrieval or fact extraction
• No ResearchAgent or orchestration layer
• No vector or episodic memory
• No file or math tools beyond calculator
• No examples directory

These will be reintroduced in Phase 3 on top of the stable Phase‑2 engine.

---

Test Suite

Phase 2 includes a comprehensive test suite:

• integration tests
• regression tests
• negative tests
• unit tests

All tests pass in a clean environment.

---

Roadmap

Phase 3 (Upcoming)

• Natural-language multi-step planning
• Pronoun resolution (“summarize it”)
• LLM-based summarization
• MemoryAgent reintroduction
• Tool selection improvements
• Real examples directory

---

License

MIT License. See LICENSE for details.