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

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.

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

Every agent execution becomes a run tree — content-addressed, serializable, forkable. Pause on your laptop, resume on a server. Branch from step 7 with a different prompt. Diff two runs side by side.

pip install opentine

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")

tine show result.tine

Matches current PyPI releases in the 0.1.x line — lightweight agent SDK, stable .tine serialization, full CLI (run, ls, show, replay, fork, diff, resume). Native adapters for Anthropic, OpenAI, Google, Ollama; OpenAI-compatible wrappers for Kimi, DeepSeek, Qwen, GLM, Groq, Together, Mistral.

Your agent fails after many steps — fork before the bad tool call instead of burning tokens from step zero:

tine show failed_run.tine
tine fork failed_run.tine --from-step 3 --save fixed_run.tine
tine diff failed_run.tine fixed_run.tine

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

Tools are plain Python callables — opentine introspects type hints. Common symbols from opentine.tools:

Optional extras (e.g. python) live in the same package when you want sandboxed scripting steps — see upstream docs.

from opentine import Agent
from opentine.models.anthropic import Anthropic
from opentine.tools import web, search, fs, shell

agent = Agent(
    model=Anthropic("claude-sonnet-4-20250514"),
    tools=[web.fetch, search.search, fs.read, fs.write, shell.run],
)

Native backends (opentine.models)

OpenAI-compatible (opentine.models.compat — one shared SDK surface)

Wire-up is always Agent(model=…(...)) after the matching from opentine.models… import (see Quickstart for a full runnable Anthropic snippet).

GitHub Analytics

Pinned Repositories

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