LiveLogic is a voice-enabled reasoning agents system that combines LiveKit for real-time voice, DSPy for structured LLM orchestration, Clingo (Answer Set Programming) as the ground-truth symbolic solver, and a Next.js React UI.

LiveLogic delivers mathematically sound security policy conversations with full auditability, explainability, and formal proof traces — not probabilistic guesses.

Unlike traditional LLM agents that can hallucinate answers and actions, LiveLogic converts natural language into first-order logic. It achieves 100% reasoning accuracy within the defined policy bounds by delegating decision-making to a symbolic solver (Clingo), using the LLM only as a linguistic interface.

User Input → DSPy Extractor → Session State (SQLite) → Clingo Solver
                                        → DSPy Critic (on UNSAT) → DSPy Translator → Output + Live Trace

1. Extract: Natural language → DSPy → valid ASP facts
2. Solve: Accumulated facts and rules → Clingo (multi-model, unsat cores)
3. Critique: UNSAT → human-readable conflict explanation with suggested retraction
4. Translate: Answer sets → natural language with step-by-step reasoning

Browser (localhost:3000)
    ↓ WebRTC
LiveKit
    ↓ 
Python Agent
    ↓ Voice API or Chat API
    ↓
    DSPy → Clingo → Voice API or Chat API → Browser

• State Accumulation: Per-session fact storage in SQLite with LRU eviction (max 50 facts)
• Conflict Detection: Two-phase consistency checks (syntactic + Clingo UNSAT)
• Fact Retraction: Dedicated endpoint for corrections
• Proactive Contradiction Alerts
• Full Audit Trail: JSON traces

• Real-time voice-to-voice
• Built-in search tools
• Audio visualizers and chat transcript
• Next.js React frontend with shadcn/ui

Handles queries like "Was this access pattern a policy violation?" reasoning over:

• User roles and permissions (RBAC)
• Resource access events with temporal constraints
• Explicit deny rules
• Session state (active users, resources)
• Time windows (e.g., "within last 24 hours")
• Multi-step reasoning (e.g., "Does this user have access to this resource?")
• Multi-model answers (e.g., "Which of these users could have accessed this resource?")
• Formal proof traces
• Policy conflict detection

Returns answers grounded in formal logic proof traces.

• LiveKit Cloud account
• [LLM API key] eg. Grok (https://console.x.ai) with Grok Voice API access
• Python 3.11+, Node.js/pnpm
• Clingo

# Backend
uv pip install livekit-agents[xai,silero,turn-detector] livekit-plugins-noise-cancellation python-dotenv

# Frontend
cd agent-ui
pnpm install

uv run grok_voice_agent_api.py download-files

Recommended: One-command

./start.sh

Or separate:

• Frontend: cd agent-ui && pnpm dev (http://localhost:3000)
• Backend: uv run grok_voice_agent_api.py dev

1. Open http://localhost:3000
2. Click "Start call"
3. Ask: "What is Elon Musk's most recent X post?"

Copy .env.example to .env.local and fill:

pip install -r requirements.txt  # DSPy, etc.
export OPENAI_API_KEY="sk-..."  # or other LLM
# Install Clingo: brew install clingo / apt-get install clingo

uvicorn reasoner.app.main:app --reload --port 8000

Example:

curl -X POST http://localhost:8000/reason -H "Content-Type: application/json" -d '{\"session_id\": "demo-1", "transcript\": "User John accessed DB at 3AM. John is analyst."}'

uv run grok_voice_agent_api.py dev     # Voice agent dev
uv run grok_voice_agent_api.py console # Local console test
uv run grok_voice_agent_api.py download-files
python tests/test_clingo.py            # Core tests

├── grok_voice_agent_api.py      # LiveKit + Grok agent
├── start.sh                     # Start script
├── agent/                       # Agent code
├── agent-ui/                    # Next.js UI (full app)
├── reasoner/                    # Core engine
│   ├── app/                     # FastAPI + DSPy + Clingo
│   └── asp/security.lp          # Policy rules
├── shared/                      # Utils
├── tests/                       # Tests
├── requirements.txt
├── pyproject.toml
└── README.md

• Phase 1: Formal Logic Engine (DSPy + Clingo + FastAPI)
• Phase 2: Voice UI (LiveKit + Grok + Next.js)
• Phase 3: Full integration (Voice → Reasoner pipeline)
• Phase 4: Polish, evals, production deploy

• LiveKit Agents
• xAI Grok Voice
• DSPy
• Clingo ASP

MIT