Building autonomous AI infrastructure, high-performance DeFi,
and privacy-first blockchain protocols from the ground up.

Dominus Node is an enterprise proxy IP service purpose-built for AI agents. Unlike traditional proxy providers, Dominus is designed from the ground up for autonomous agent workflows — providing a plugin and tool ecosystem that AI agents can discover, install, configure, and operate without human intervention.

Every integration is designed for autonomous installation and self-management — agents discover the plugin they need, install it, authenticate, and begin routing traffic through the proxy mesh with zero human setup.

AI Agent Frameworks Plugin Framework dominusnode-langchain LangChain dominusnode-crewai CrewAI dominusnode-llamaindex LlamaIndex dominusnode-autogpt AutoGPT dominusnode-metagpt MetaGPT dominusnode-superagi SuperAGI dominusnode-pydantic-ai Pydantic AI dominusnode-camel-ai CAMEL-AI dominusnode-agno Agno dominusnode-agent--zero Agent Zero dominusnode-semantic-kernel Semantic Kernel dominusnode-haystack Haystack dominusnode-composio Composio

Platforms & Orchestration Plugin Platform dominusnode-n8n n8n dominusnode-flowise Flowise dominusnode-dify Dify dominusnode-mastra Mastra dominusnode-vercel-ai Vercel AI SDK dominusnode-moltbook Moltbook dominusnode-openclaw OpenClaw dominusnode-ironclaw IronClaw mcp-server MCP Server LLM Provider Plugins Plugin Provider dominusnode-openai OpenAI dominusnode-gemini Google Gemini dominusnode-chatgpt ChatGPT dominusnode-pi Pi

Core SDKs SDK Language dominusnode-python dominusnode-node dominusnode-go dominusnode-rust dominusnode-java dominusnode-cpp Key Capabilities Autonomous plugin discovery & install Programmatic account provisioning API key rotation & billing controls Sticky sessions & IP rotation Geo-targeting & concurrent sessions Per-agent bandwidth telemetry MCP tool server for Claude/GPT agents Zero human intervention workflows

SOLIDUS NETWORK — High-Performance Multi-Chain Perps Exchange

Solidus Network is a high-performance perpetuals exchange built on a multi-algorithm, multi-chain DAGKNIGHT architecture. Forked from Quai Network and re-engineered with 4 zones per region, each running a different mining algorithm for a different hardware class — ASIC, GPU, CPU, and Mobile miners all participate without competing against each other. Built-in perps core with on-chain order matching. Research benchmarks are matching Hyperliquid-class speeds and TPS.

DAGKNIGHT consensus runs at the zone level where transaction throughput matters. Region and Prime chains use entropic block ordering

Each region contains 4 parallel zones, each running a distinct consensus algorithm. Miners of different hardware classes never compete against each other — each class has its own dedicated zone with balanced difficulty, ensuring fair participation from enterprise ASICs down to mobile devices.

Innova is a hybrid PoW/PoS privacy blockchain with 1,500+ commits, built on the Tribus hashing algorithm (three NIST5 algorithms), ~15s block times, and a hardcapped 18M supply. Five-layer privacy architecture, decentralized services layer, and a Collateral Node network.

_{¹ Layer 4 Silent Shielding: RPC commands registered (sp_send, sp_getnewaddress);}

The first block DAG with DAGKNIGHT adaptive ordering, PoS finality, and full zero-knowledge privacy.

IDAG is Innova's next-generation consensus — a four-phase migration from linear blockchain to a high-throughput block DAG. First to implement epoch-anchored FCMP++ membership proofs in a DAG and adaptive DAGKNIGHT k inference.

INVS is the shielded asset layer within the Innova ecosystem — fully private value transfer with ZK-proof verification, leveraging all five privacy layers and IDAG's throughput for high-frequency confidential transactions.

Project Lavalamp is a hardware-software security product that masks the AMD Zen 5 SMT port contention timing side-channel — a 27.6% signal leakage vulnerability that AMD, Google, Microsoft, and NVIDIA all declined to fix. At its core is a proprietary entropy engine that generates high-quality dither patterns to bury timing signals below the detection floor. Validated on live FPGA hardware — 8/8 NIST-class statistical quality tests pass, 98.4% Shannon entropy efficiency, with integrity sealing across every released bitstream.

• Hardware validation complete on the Artix-7 reference platform — full end-to-end signal-masking loop running on live silicon.
• Shield (software) tier daemon feature-complete on x86 and ARM Neoverse with 93% leak reduction at ~6% CPU overhead.
• Lite (USB-FPGA) tier shipping across 7 Artix-7 boards with 99%+ leak reduction at <1% host overhead.
• Pro (PCIe) tier in active development — kernel driver and TLP-inference pipeline under bring-up.
• Phase 2 porting effort underway — extending the FPGA build system to 17 boards across 6 vendors.

One command per supported board — vivado -mode batch -source build_board.tcl -tclargs <board>. Currently shipping on the Artix-7 family; Phase 2 validates across 17 FPGA boards spanning 6 vendors (AMD/Xilinx, Intel/Altera, Lattice, Gowin, Microchip).

Disabling SMT mitigates the leak but costs ~50% of compute capacity. Lavalamp recovers 97% of that capacity while reducing leakage by 93–99% depending on tier. No other product targets this specific vulnerability at the hardware level.

opentine is git for agent runs. Every AI agent execution becomes a content-addressed run tree — forkable, replayable, diffable, and serializable to disk. Pause on your laptop, resume on a server. Branch from step 7 with a different prompt. Diff two runs side by side. The core is ~250 lines of Python, model-agnostic, and has zero framework lock-in.

A tine is the prong of a fork. opentine literally forks your agent runs.

• Public release on PyPI — pip install opentine, Apache 2.0, zero framework lock-in.
• Multi-provider adapters shipped — native support for Anthropic, OpenAI, Google, and Ollama, plus OpenAI-compatible wrappers for Kimi, DeepSeek, Qwen, GLM, Groq, Together, and Mistral.
• Full CLI surface live — run, ls, show, replay, fork, diff, resume.
• Serialization format stable — .tine run trees are portable across machines; pause on laptop, resume on a server.
• Next up — remote run sync, hosted replay viewer, and tighter integrations with agent frameworks that already appear on the comparison table below.

tine run <script.py>          Execute agent, stream steps, save run tree
tine ls                       List recent runs (status, cost, model)
tine show <run_id>            Pretty-print the tree (like git log --graph)
tine replay <id> [--from N]   Replay from a step
tine fork <id> --from-step N  Branch a new run
tine diff <run_a> <run_b>     Side-by-side comparison
tine resume <run_id>          Resume a paused run

Treats every provider equally. Swap with one line — native adapters for Anthropic, OpenAI, Google, Ollama, plus OpenAI-compatible wrappers for Kimi, DeepSeek, Qwen, GLM, Groq, Together, Mistral.

from opentine import Agent
from opentine.models.anthropic import Anthropic

agent = Agent(model=Anthropic("claude-sonnet-4-20250514"))
run = agent.run_sync("What is opentine?")
run.save("result.tine")

GitHub Analytics

Pinned Repositories

_{Building autonomous AI infrastructure, high-performance DeFi, and privacy-first blockchain protocols.}