Warning
🚧 WIP — Active AI Pipeline Construction & Architecture Optimization in Progress.
⚡ Multi-step reasoning, Chain-of-Thought (CoT), Tree-of-Thoughts (ToT), and heuristic path evaluation — Deep cognitive planning engine for the FastJava AI ecosystem.
FastAIReasoner provides structured cognitive search and reasoning capabilities for Java AI agents. It evaluates solution paths, explores branch states, and performs self-consistency verification before actions are executed in FastAIAgent or FastAIRuntime.
import fastai.AI;
import fastai.FastAI;
import fastaireasoner.FastAIReasoner;
import fastaireasoner.ReasoningResult;
public class Demo {
public static void main(String[] args) {
AI brain = FastAI.connect("ollama:qwen2.5-coder:7b");
// 1. Instantiate reasoning engine with Tree-of-Thoughts (ToT) strategy
FastAIReasoner reasoner = FastAIReasoner.treeOfThoughts(brain, 3 /* branches */, 2 /* depth */);
// 2. Perform deep reasoning on complex architectural problem
ReasoningResult result = reasoner.reason("Design a lock-free event dispatcher in Java");
System.out.println("Best Plan: " + result.bestPath());
System.out.println("Confidence: " + result.confidenceScore());
}
}- Why FastAIReasoner?
- Key Features
- Architecture Overview
- API Quick Reference
- Technical Demos & Benchmarks
- Installation
- Documentation
- Platform Support
- License
- Related Projects
Standard LLM prompting generates linear, token-by-token text without internal verification, leading to hallucinations, circular logic, and brittle plans in multi-step enterprise workflows. FastAIReasoner transforms raw generative models into disciplined problem-solving engines through deliberate heuristic search and self-evaluation:
- State-Space Exploration — Explores alternative branching thoughts before committing to irreversible actions.
- Self-Consistency Scoring — Samples multiple rationale paths and ranks the most dependable strategy.
- Agent Integration — Directly plugs into
FastAIAgent's planning and reflection phases. - Zero Framework Overhead — Pure Java 17+ architecture with sub-millisecond graph evaluation.
| Feature | Standard LLM Prompting | LangChain / LangGraph | FastAIReasoner |
|---|---|---|---|
| Reasoning Model | Linear single-pass | Graph DSL overhead | Chain-of-Thought & Tree-of-Thoughts |
| Branch Exploration | ❌ None | ✅ Native multi-branch state evaluation | |
| Confidence Scoring | ❌ None | ✅ Built-in confidence metrics | |
| Memory Footprint | Low | High (Python / bulky JVM) | Zero-bloat, pure Java 17+ |
| Ecosystem Synergy | Standalone | Fragmented | Native fit with FastAI & FastAIAgent |
- 🌲 Tree-of-Thoughts (ToT) — Explores tree-structured rationale paths with branch pruning.
- 🔗 Chain-of-Thought (CoT) — Step-by-step sequential deduction with explicit verification gates.
- 🎯 Confidence Scoring — Evaluates rationale coherence with threshold-based confidence checks.
- ⚡ Zero-Bloat Cognitive Engine — Lightweight Java record structures and lock-free execution.
- 🔌 Seamless FastAI Integration — Works out-of-the-box with any model supported by
FastAI.
- 🧠 FastAIReasoner (The Reasoner & Planning Engine): Evaluates cognitive hypotheses, scores branches, and outputs optimal execution plans.
- 🤖 FastAIAgent (The Mind): Consumes reasoning plans and orchestrates the ReAct loop (
Observe → Plan → Act → Reflect → Memory). - ⚡ FastAIRuntime (The Body): Executes deterministic tool actions selected by the reasoner.
| Method / Factory | Return Type | Description |
|---|---|---|
FastAIReasoner.chainOfThought(AI) |
FastAIReasoner |
Sequential reasoning pipeline with step validation. |
FastAIReasoner.treeOfThoughts(AI, int, int) |
FastAIReasoner |
Branching tree search exploring multiple candidate thoughts. |
reasoner.reason(String goal) |
ReasoningResult |
Evaluates the goal and returns the highest-scoring plan path. |
result.isConfident() |
boolean |
Verifies whether confidence score meets threshold (>= 0.70). |
| Case | Java Example | Launcher | Description |
|---|---|---|---|
| Cognitive Planning Demo | Demo.java | run-demo.bat |
Chain-of-Thought (CoT) and Tree-of-Thoughts (ToT) multi-branch planning demo. |
| JMH Microbenchmark Suite | Benchmark.java | run-benchmark.bat |
JMH throughput benchmark measuring deduction and state exploration speed. |
Add the JitPack repository and the dependencies to your pom.xml:
<repositories>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
</repository>
</repositories>
<dependencies>
<!-- FastAIReasoner Library -->
<dependency>
<groupId>com.github.andrestubbe</groupId>
<artifactId>FastAIReasoner</artifactId>
<version>0.1.0</version>
</dependency>
<!-- FastAI (Unified AI Client) -->
<dependency>
<groupId>com.github.andrestubbe</groupId>
<artifactId>fastai</artifactId>
<version>0.1.4</version>
</dependency>
</dependencies>repositories {
maven { url 'https://jitpack.io' }
}
dependencies {
implementation 'com.github.andrestubbe:FastAIReasoner:0.1.0'
implementation 'com.github.andrestubbe:fastai:0.1.4'
}Download the latest JARs directly to add them to your classpath:
- 📦 FastAIReasoner-0.1.0.jar (The Core Library)
- ⚙️ fastcore-0.1.0.jar (The Mandatory Native Loader)
- REFERENCE.md: Core API reference manual.
- PHILOSOPHY.md: Multi-step reasoning and cognitive planning architecture.
- COMPILE.md: Build instructions.
- CHANGELOG.md: Project history and releases.
- ROADMAP.md: Future milestones.
| Operating System | Architecture | Build Status | Support Level |
|---|---|---|---|
| Windows 10 / 11 | x64 |
 |
Tier 1 (Primary / Optimized) |
| Linux (Ubuntu / RHEL) | x64 |
|
Tier 1 (Pure Java Engine) |
| macOS (Sonoma+) | Apple Silicon (arm64) |
|
Tier 1 (Pure Java Engine) |
| macOS | x64 |
|
Tier 2 (Supported) |
MIT License — See LICENSE file for details.
- FastAI — Unified AI client interface for Java
- FastAIAgent — Autonomous agent loop, intent-graphs, and tool execution
- FastAIBot — Zero-bloat bot harnesses and persona runtime
- FastAIEval — Ultra-fast LLM & agent evaluation framework
- FastAIGraph — In-memory knowledge graph and multi-hop relationship engine
- FastAIGuard — Fast guardrails, prompt safety, and hallucination containment
- FastAIHybrid — Dense-sparse hybrid search fusion (BM25 + Vectors)
- FastAIMatcher — Automated SOX compliance and hybrid rule matching engine
- FastAIMCP — Model Context Protocol (MCP) server & tool integration
- FastAIMemory — Conversation history, sliding windows, and rolling summaries
- FastAIMemoryGraph — Graph-based episodic and associative memory engine
- FastAIMetrics — Ultra-fast lock-free token, latency, cost tracking and evaluation engine
- FastAIModel — Native local inference runtime (GGUF/ONNX)
- FastAIRag — Ultra-fast document chunking and vector retrieval
- FastAIRerank — Cross-encoder relevance filtering and Top-N prompt pruner
- FastAIRuntime — Sandboxed process runner and tool-calling execution pipeline
- FastAISandbox — Lightweight isolated execution environment for untrusted AI tools
- FastAISkill — Modular capability registry and dynamic tool dispatch
- FastAIState — Lock-free shared agent state & blackboard memory
- FastAIVectorDB — High-throughput SIMD/AVX2 vector database
- FastAIVision — High-speed local multimodal vision, UI-element grounding, and screen-VLM engine
- FastCore — Unified JNI loader and platform abstraction
Part of the FastJava Ecosystem — Making the JVM faster. Small package. Maximum speed. Zero bloat. 🚀📋