Run Jev-Style System One Models Locally

A Complete Guide to Ollaya and Local Decision Models

Introduction

Chapter 1: What Is a Decision Model?

1. The Problem LLMs Were Never Built to Solve
2. Decision Models vs. Language Models: Different Jobs
3. Why Structure Matters in AI Systems
4. Enter the Jev Paradigm
5. What You Will Learn From This Book

Chapter 2: Jev-Style Decision Models: From First Principles

1. The Jev System: Origins and Purpose
2. State, Questions and Choices: Core Primitives
3. Typed Decisions and Probability Distributions
4. Confidence, Calibration and Score Interpretation
5. Single-Pass Inference and the No-Generation Constraint
6. How Decision Models Avoid Hallucination by Design

Chapter 3: Architecture Comparison: Decision Models vs. LLMs

1. Training Objectives and Loss Functions
2. Output Spaces: Tokens vs. Typed Decisions
3. Inference Behavior and Compute Patterns
4. Latency, Throughput and Memory Usage
5. Probability Interpretation and Calibration
6. Hallucination, Determinism and Reliability
7. Cost, Privacy and Operational Characteristics
8. Summary: When to Use Each

Chapter 4: The Ollaya Project: Landscape and Positioning

1. What Is Ollaya?
2. Ollaya, Jev and TypeSafe: Mapping the Relationships
3. Open Decision Models and Compatibility
4. What “Jev-Style” and “Jev-Compatible” Actually Mean
5. Project History, Community and Governance
6. Getting Started Prerequisites

Chapter 5: Installing Ollaya

1. Supported Operating Systems
2. Hardware Requirements and Recommendations
3. Installation via Install Script (Linux/macOS)
4. Installation via Package Managers
5. Docker and Containerized Installation
6. Verifying Your Installation
7. CPU vs. GPU Execution Setup
8. Environment Variables and Server Configuration
9. Troubleshooting Installation
10. Next Steps

Chapter 6: Your First Local Decision Model

1. Understanding the Model Registry
2. Pulling Your First Model
3. Running a Model with ollaya run
4. Reading the Output: Decisions, Scores and Confidence
5. Listing Installed Models
6. Inspecting Model Details with show
7. Stopping and Managing Running Models
8. Interactive REPL Mode
9. Removing Models
10. Your First Custom Questions

Chapter 7: The Ollaya Command-Line Reference

1. Command Overview
2. The Pull Command: Fetching Models
3. The Run Command: Inference Basics
4. The List Command: Inventory Management
5. The Show Command: Model Metadata
6. The Ps and Stop Commands: Process Control
7. The Create, Cp and Rm Commands: Lifecycle
8. Environment Variables and Configuration
9. Advanced Run Patterns
10. Summary Table

Chapter 8: Modelfiles and Custom Model Configurations

1. What Is a Modelfile?
2. Modelfile Syntax and Structure
3. Defining Question Sets and Choice Spaces
4. Building a Custom Model from Scratch
5. Model Presets and Inheritance
6. Calibration Settings
7. Parameter Settings
8. Validation and Testing Your Custom Models

Chapter 9: Running a Local Ollaya Daemon

1. Starting the Ollaya Server
2. Server Configuration and Ports
3. Authentication and Access Control
4. Resource Limits and Process Management
5. Health Checks and Monitoring
6. Running Ollaya as a Systemd Service (Linux)
7. Running Ollaya in Docker
8. Security Considerations
9. Next Steps

Chapter 10: The Local Decision Model API

1. API Endpoints Overview
2. The Generate/Run Endpoint
3. Request Format: Questions, State and Options
4. Response Format: Decisions, Scores and Metadata
5. Streaming and Batch Requests
6. Error Handling and Status Codes
7. API Examples with curl

Chapter 11: Integrating with Python

1. Setting Up a Python Project for Ollaya
2. Making API Calls with requests and httpx
3. Building a Typed Client Library
4. Error Handling and Retries
5. Batch Processing and Concurrency
6. Production Python Integration Example

Chapter 12: Integrating with JavaScript and TypeScript

1. Node.js Integration Patterns
2. TypeScript Type Definitions for Decision Responses
3. Browser-Based Calls to Local Ollaya
4. Error Handling and Resilience
5. Full Example: TypeScript Decision Service Client
6. Express.js Integration Example

Chapter 13: The TypeSafe API and Jev Integration Patterns

1. What Is the TypeSafe API?
2. Cloud Jev vs. Local Ollaya: API Alignment
3. Migrating from TypeSafe Cloud to Local Endpoints
4. What Changes, What Stays the Same
5. Configuration and Environment Management
6. Type-Safe Decision Handling in Your Code

Chapter 14: Designing Good Decision Schemas

1. Principles of Typed Question Design
2. Label Space Construction and Granularity
3. Score Ranges and Thresholds
4. Decision Hierarchies and Multi-Stage Decisions
5. Abstention and Human-in-the-Loop Patterns
6. Schema Evolution and Versioning

Chapter 15: Real-World Application: Customer Support Triage

1. Problem Statement and Requirements
2. Decision Schema Design for Triage
3. Building the Ollaya Modelfile
4. Implementing the Application Backend
5. Integration with Messaging and Routing
6. Testing and Validation

Chapter 16: Real-World Application: Intent Classification and Routing

1. Intent Classification as a Decision Problem
2. Designing the Intent Schema
3. Implementing the Router Service
4. Tool Selection and Agent Integration
5. Handling Ambiguity and Edge Cases

Chapter 17: Real-World Application: Moderation and Risk Signals

1. Moderation as Structured Decision-Making
2. Multi-Label Decision Schemas
3. Confidence Thresholds and Escalation
4. Combining Signals for Risk Assessment
5. Audit Trails and Explainability

Chapter 18: Hybrid Architectures: LLMs and Decision Models Together

1. Division of Labor: What Each Model Should Do
2. Decision Models as Gatekeepers for LLMs
3. LLMs Generating Candidates, Decision Models Scoring
4. Architectural Patterns and Diagrams
5. Cost and Latency Considerations

Chapter 19: MCP and Agent Integration

1. Understanding MCP for Decision Models
2. Ollaya as an MCP Server
3. Integrating Decision Models into Agentic Workflows
4. Tool Calling with Decision Outputs
5. Practical Integration Examples

Chapter 20: Evaluation and Validation

1. Evaluation Metrics for Decision Models
2. Building a Golden Dataset
3. Accuracy, Precision, Recall and Calibration
4. A/B Testing Decision Schemas
5. Continuous Evaluation Pipelines

Chapter 21: Performance, Benchmarking and Optimization

1. Benchmarking Methodology
2. Latency and Throughput Measurements
3. CPU vs. GPU Performance
4. Batching and Concurrency Strategies
5. Memory Management and Model Loading
6. Caching and Optimization Techniques

Chapter 22: Observability, Logging and Debugging

1. Logging Decisions and Metadata
2. Structured Logs and Observability Tools
3. Debugging Decision Outputs
4. Tracing Decision Paths
5. Performance Monitoring Dashboards

Chapter 23: Security and Privacy

1. Data Privacy Advantages of Local Execution
2. Network Security and API Hardening
3. Model Integrity and Supply Chain
4. Input Validation and Abuse Prevention
5. Compliance and Regulatory Considerations

Chapter 24: Production Deployment

1. Deployment Architecture Patterns
2. Kubernetes and Container Orchestration
3. Autoscaling and Load Balancing
4. Multi-Model Serving and Routing
5. Backup, Recovery and Disaster Planning

Chapter 25: Conclusion: The Future of Local Decision Models

1. What We Have Learned
2. The Case for Decision Models in Modern AI
3. Trends and Open Questions
4. Next Steps for Practitioners

References