Our Active Projects
From protocols to runtimes to trained models — these are the projects we build and use in production.
Golden Hen Suite
XCT taken to its extreme — three self-custody engines for managing wealth on-chain, where the model steps out of the hot path entirely. Harvest accumulates SOL from volatility; Treasury preserves it; Pirate hunts asymmetric bets. Deterministic pipelines execute, the model supervises, and the books reconcile against the blockchain, cent for cent.
Why It Matters
- The model out of the execution path — determinism runs the money
- Four-term ledger that reconciles with on-chain reality (gas + dust)
- SOL-first: accumulates SOL from volatility, not directional bets
- Self-custody appliance — the client's box, wallet, and keys
Built With
XCT-Qwen3-4B
An execution-oriented language model fine-tuned with LoRA to operate under the XCT Protocol. Not a conversational assistant — a constrained execution engine for controlled, deterministic systems.
Model Specs
Quantized Variants (GGUF)
Designed For
- Deterministic execution agents
- Infrastructure orchestration (K8s, CI/CD)
- Deployment automation pipelines
- Tool-driven workflows
- Compliance-sensitive environments
Execution Model
Polaris v3
This is not a chatbot — it's a deterministic execution agent powered by the XCT Protocol. The model proposes one action at a time, the system validates, deterministic tools execute. Designed to be customized to your use case: each deployment gets its own tool set, validation rules, and execution boundaries tailored to the problem at hand. Built for critical automation where reliability is non-negotiable.
XCT Execution Flow
Tool Ecosystem
Architecture
- Clean Architecture with layered separation
- FastAPI REST + WebSocket executor
- RAG with ChromaDB for contextual retrieval
- MongoDB dual-layer memory (short + long term)
- Local inference (Polaris Core) or Groq Cloud
- Hot-reload configuration without restarts
- Prometheus metrics and observability
Polaris v2
Conversational AI assistant for companies that need a chatbot with guardrails — not a toy. RAG over your documents, voice input/output, multi-platform delivery (web, Telegram, API), deployable on your infrastructure or cloud. Your models, your data, your rules.
Capabilities
Infrastructure Options
Architecture
- FastAPI backend with JWT authentication
- MongoDB persistence + ChromaDB vector store
- LangChain context management
- Dynamic model selection (local or cloud)
- Prometheus metrics and observability
- Docker Compose deployment
Polaris Core
Ultra-optimized C++ binding for llama.cpp with first-class Python integration. Built for maximum-performance local inference with streaming, XCT protocol support, and intelligent batch management.
Features
- GGUF model support (Qwen, Mistral, LLaMA, Gemma)
- GPU acceleration via CUDA (CPU/Metal also supported)
- Token streaming through Python callbacks
- JSON early-stop for XCT protocol (~30% time savings)
- Intelligent batch backoff with automatic retry
- Thread-safe architecture with GIL management
Performance (Qwen3-4B · RTX 4090)
XCT — Execution Control Transfer
An architectural protocol that keeps language models from granting themselves executive authority. XCT inverts the sovereignty model: models propose, but don't execute. Control remains with deterministic tools. Born from production experience with high-risk AI deployments.
Protocol Principles
- No action without explicit tool invocation
- One step per iteration — controlled loop
- Errors are first-class control signals
- System has veto power over any proposal
- Ambiguity resolves to minimal action
Why XCT Exists
XCT is not a prompt style or agent framework — it's an architectural protocol. Traditional AI integrations let models decide what to do and when. XCT inverts this: the model proposes, the system validates, deterministic tools execute. Authority remains external by design.