How F3L1X Works

Stop doing repetitive work. F3L1X turns your computer into a team of AI workers that automate tedious tasks - from documentation to testing to code optimization - while you stay in control.

No cloud subscriptions. No data leaving your machine. Just your computer doing more work so you can do less.

Note: Claude Code is currently required for full functionality. Local alternatives are in development. Learn more ↓

The Foundation

Your Personal AI Data Center

F3L1X transforms your computer into a server running autonomous AI agents. Each agent operates in a specialized "Realm" - a domain with its own expertise and capabilities.

Summon any realm just by saying its name. Every realm has a memorable name that tells you exactly what it does:

  • doc-u-me - your documentation search and indexing tool
  • pipeline-go - your development pipeline and CI/CD methodology
  • worker-bee - ecosystem health verification and session logging
  • sov-ai - unified local AI infrastructure with Ollama integration
  • euclid-boy - efficiency optimization using advanced algorithms
  • test-master - generates and runs tests automatically
  • upgraydd - discovers advanced features and plans enhancements

Think of it like having a team of specialists on call - each realm handles its own job, and F3L1X makes sure they work together without stepping on each other's toes.

F3L1X Orchestration Layer
↓
herald
doc-u-me
test-master
upgraydd
euclid-boy
↓
Your Local Computer

Natural Language Control

Chain Realms Together in Plain English

The real power comes from combining realms. String their names together in a single sentence, and they work as a team:

"Use pipeline-go and doc-u-me to search through the documentation, then use euclid-boy and test-master to develop tests for the application. Use upgraydd to find advanced features we could add."

That single instruction activates five realms working in sequence. Each one understands its role and passes context to the next.

Self-improving by design. Realms can rewrite themselves as needed to fit any requirement. If a realm doesn't do exactly what you need, it can be modified, extended, or combined with others to create entirely new capabilities.

Your Request
↓
pipeline-go
doc-u-me
↓
euclid-boy
test-master
↓
upgraydd
↓
Result

Intelligent Collaboration

Two-Way AI Communication

F3L1X enables true two-way communication between you and AI agents. Claude Code provides the cognitive engine while F3L1X provides the orchestration layer.

  • CLAUDE.md - AI reads project configuration and instructions
  • ACTIVITY_LOG.md - AI writes session context and progress
  • Pipeline-go - Semantic understanding through structured methodology

This creates a persistent memory across sessions. The AI knows what happened before, what's blocked, and what needs to happen next.

You
Claude Code
↕
F3L1X Layer
↕
CLAUDE.md
ACTIVITY_LOG

Herald Messaging System

Secure Inter-Realm Communication

Herald is your local message broker - a secure switchboard that routes messages between realms using REST API calls and WebSocket connections. Everything runs on localhost (127.0.0.1), so traffic never leaves your machine.

  • Local REST API for realm-to-realm messaging (localhost only)
  • WebSocket streaming for real-time terminal output
  • Zero external exposure - all ports bound to 127.0.0.1
  • No internet required for inter-realm communication

Your data stays on your machine. Herald is like an internal phone system - realms talk to each other, but the calls never leave the building.

# Herald broadcasts realm events POST /api/broadcast/ { "source": "doc-u-me", "event": "document_created", "document": "API-SPEC.md", "affected_realms": [ "test-master", "herald" ] }

Test-Driven Development

Code That Tests Itself

F3L1X uses Django's built-in test framework with Test-Driven Development (TDD) baked into the methodology. The test-master realm generates tests from activity logs.

  • Django TestCase for database isolation
  • Automatic test generation from activity logs
  • Continuous validation of functionality
  • TDD workflow - write test first, then implement

Programs can validate their own functionality. When you make changes, the system knows what to test and how to verify it works.

# TDD Workflow class RealmTests(TestCase): def test_herald_broadcast(self): # 1. Write the test first response = self.client.post( '/api/broadcast/', data={'event': 'test'} ) self.assertEqual( response.status_code, 200 ) # 2. Run test (fails) # 3. Implement feature # 4. Run test (passes)

Pipeline-Go Methodology

Built for Deployment

Pipeline-go is the rapid deployment framework for Django applications. It enables trunk-based development with high-coverage CI/CD.

  • From prototype to production in hours, not weeks
  • Trunk-based development - single main branch
  • High-coverage CI/CD - automated testing and deployment
  • Railway, Render, or self-hosted deployment options

The methodology is documented in ~/.claude/pipeline-go.md and automatically loaded for every Claude Code session.

Write Code
↓
Run Tests
↓
collectstatic
↓
Deploy to Production

Data Sovereignty

Own Your Intelligence

F3L1X supports local AI inference through NVIDIA GPUs and Ollama. After initial setup, you have no ongoing API costs or subscription dependencies.

  • NVIDIA GPUs + Ollama for local inference
  • No API costs after setup
  • No subscription dependencies
  • Full data sovereignty - your data never leaves your machine

Cloud AI is optional. For sensitive work, run everything locally with complete control over your data and models.

Current Development Status

Claude Code is currently required for full AI coding functionality. While sov-ai can run models locally via Ollama, it doesn't yet match Claude Code's capabilities.

You have options: wait for updates as we improve these agents, or build the capabilities yourself. That's the beauty of the F3L1X ecosystem—if you want something done better, you have all the tools to do it.

Your Prompts
↓
Ollama (Local)
↓
Mistral
Llama
CodeLlama
↓
Response (Never Leaves)

Persistent Memory

The System Remembers

F3L1X builds context over time. Every session is logged, indexed, and available for future reference. The more you use it, the more effective it becomes.

  • ACTIVITY_LOG.md captures every session
  • doc-u-me indexes documentation and tracks blockers
  • mr-greet checks status and suggests next actions
  • Context builds with every interaction

Start a new session and the AI already knows your project structure, what you worked on last time, and what blockers need resolution.

# Pre-session protocol $ hello f3l1x Checking ecosystem health... Dashboard: Running Herald: Running Doc-u-me: Running Active Blockers: 2 - [ ] Update CSS architecture - [ ] Add documentation portal Last session: 2h ago Suggested: Continue CSS cleanup

Authorization & Security

F3L1X only accesses the internet for license authorization.

All realm communication stays on your local machine. Your code, your data, your prompts - nothing leaves your environment without your explicit action.

Running without a valid authorization token is not supported and may compromise system integrity.

Still Not Getting It?

We get it. There's a lot of technical complexity behind F3L1X. We've created a page that explains everything in two ways: the simple version for getting started, and the deep technical details for those who want to understand the architecture.

I Don't Get It - Explain It To Me

Ready to Get Started?

Download F3L1X and transform your computer into a personal AI data center. Own your data. Own your agents. Own your business.

Download F3L1X