Documentation — LogicCycle AI

Introduction

LogicCycle AI is a reasoning-based AI agentic workflow platform. It enables you to build AI agents that think in structured logic loops — retrieving context, reasoning through multi-step chains, validating outputs, and self-correcting when confidence thresholds aren't met.

Unlike traditional prompt-and-response AI, LogicCycle agents operate in cycles: iterative reasoning passes that converge on deterministic, auditable outputs.

Quickstart

Get your first logic cycle running in under 5 minutes.

1. Install the SDK

pip install logiccycle

2. Initialize an Engine

from logiccycle import LogicEngine

engine = LogicEngine(
    model="gpt-4-turbo",
    grounding="rag",
    max_iterations=5
)

3. Run a Cycle

from logiccycle import Agent, Cycle

cycle = Cycle(
    name="document-analysis",
    convergence_threshold=0.95
)

agent = Agent(engine=engine, cycle=cycle)
result = agent.run(
    task="Summarize key risks in this contract",
    context=my_documents
)

print(result.output)
print(result.trace)  # Full reasoning trace

Core Concepts

Logic Engine

The Logic Engine is the reasoning core. It takes an input task and context, decomposes the problem into logical steps using chain-of-thought prompting, and validates each inference before proceeding. It supports RAG-based grounding for factual accuracy.

Cycle

A Cycle defines the iterative behavior of an agent. Each cycle pass refines the output. You configure convergence thresholds, maximum iterations, and exit conditions. When confidence drops below threshold, the agent automatically enters a self-correction loop.

Agent

An Agent combines an Engine and a Cycle. It's the top-level abstraction you deploy. Agents can be composed into pipelines, monitored via the Governance dashboard, and versioned for reproducibility.

Logic Engine Guide

The Logic Engine supports multiple reasoning strategies:

Chain-of-Thought (CoT) — Step-by-step decomposition for complex tasks
Tree-of-Thought (ToT) — Branching exploration for ambiguous problems
RAG Grounding — Vector-store retrieval for factual anchoring

engine = LogicEngine(
    model="gpt-4-turbo",
    strategy="tree-of-thought",
    grounding="rag",
    vector_store="pinecone",
    max_branches=4
)

Cycle Orchestrator Guide

The Cycle Orchestrator provides a visual interface for defining agent logic flows. You can also define cycles programmatically:

from logiccycle import Cycle, Condition

cycle = Cycle(
    name="risk-assessment",
    convergence_threshold=0.95,
    max_iterations=10,
    exit_conditions=[
        Condition.confidence_above(0.95),
        Condition.max_iterations(10),
        Condition.no_drift(window=3)
    ]
)

Governance & Audit Guide

Every logic cycle produces a full audit trail. Access traces programmatically or through the dashboard:

result = agent.run(task="...", context=docs)

for step in result.trace.steps:
    print(f"[{step.timestamp}] {step.action}: {step.detail}")
    print(f"  Confidence: {step.confidence}")
    print(f"  Grounded: {step.grounded}")

Integrations

LogicCycle AI integrates with your existing stack:

Vector Databases — Pinecone, Milvus, Weaviate, Qdrant
LLM Providers — OpenAI, Anthropic, Azure OpenAI, local models via Ollama
Observability — OpenTelemetry, Datadog, Grafana
CI/CD — GitHub Actions, GitLab CI, Jenkins

LogicCycle AI Docs