# ainative

> AI Native Business — the book and companion software from Orionfold, an AI studio building open software, custom models, and local-first AI playbooks.

## About

ainative is the companion software for the AI Native Business book by Manav Sehgal — a 14-chapter playbook for building autonomous business systems. The runtime is local-first (Tauri), open source (Apache 2.0), and free.

### Five Differentiation Pillars

1. **Long-Horizon Task Persistence** — Tasks that survive beyond sessions with checkpoint/resume, progress tracking, failure recovery, and per-task resource budgets.
2. **Multi-Model Orchestration** — Routes subtasks to the best available model (Claude, GPT, Gemini, Grok, Ollama) based on measured performance.
3. **Memory-Native Architecture** — Four-tier hierarchical memory (working, episodic, semantic, procedural) with hybrid retrieval (BM25 + vector + MMR).
4. **Graduated Autonomy** — Trust earned through demonstrated competence. Supervised → semi-autonomous → autonomous, scoped per-agent-type and per-risk-level.
5. **Hybrid Execution** — Desktop-native with cloud reach. Same task graph runs locally or in the cloud with state portability.

### Status

- License: Apache 2.0
- Stage: Pre-alpha (active development)
- Author: Manav Sehgal

## Documentation

- [Homepage](https://ainative.business/): Book + companion software overview, architecture, research
- [The Book](https://ainative.business/book/): AI Native Business — the 14-chapter playbook
- [Field Notes](https://ainative.business/field-notes/): Running editorial log — 56 published articles
- [About](https://ainative.business/about/): Manav Sehgal — author bio, credentials, and contact
- [Projects](https://ainative.business/projects/): 25-year project portfolio across five technology waves
- [Docs](https://ainative.business/docs/): Reference for the companion software — agents, tasks, workflows, memory, governance
- [API Reference](https://ainative.business/docs/api/): REST and local API surface for ainative-business
- [Fieldkit](https://ainative.business/fieldkit/): Open-source CLI for AI-native infrastructure on workstations

## Book Chapters

### Part 1 — The Blueprint
- [Ch 1: From Hierarchy to Intelligence](https://ainative.business/book/ch-1-from-hierarchy-to-intelligence/) —: Two Thousand Years of Organizational Design — and Why It's About to Break
- [Ch 2: The AI-Native Blueprint](https://ainative.business/book/ch-2-the-ai-native-blueprint/) —: From Factory Metaphor to Working Architecture
### Part 2 — The Factory
- [Ch 3: The Refinery](https://ainative.business/book/ch-3-the-refinery/) —: From Intent to Structured Work
- [Ch 4: The Forge](https://ainative.business/book/ch-4-the-forge/) —: Task Execution at Scale
- [Ch 5: Blueprints](https://ainative.business/book/ch-5-blueprints/) —: Workflow Orchestration
- [Ch 6: The Arena](https://ainative.business/book/ch-6-the-arena/) —: Scheduled Intelligence
### Part 3 — The Network
- [Ch 7: Institutional Memory](https://ainative.business/book/ch-7-institutional-memory/) —: The Knowledge Graph
- [Ch 8: The Swarm](https://ainative.business/book/ch-8-the-swarm/) —: Multi-Agent Coordination
- [Ch 9: The Governance Layer](https://ainative.business/book/ch-9-the-governance-layer/) —: Trust at Scale
### Part 4 — The Vision
- [Ch 10: The World Model](https://ainative.business/book/ch-10-the-world-model/) —: From Project State to Organizational Intelligence
- [Ch 11: The Machine That Builds Machines](https://ainative.business/book/ch-11-the-machine-that-builds-machines/) —: ainative-business Building Itself Using Itself
- [Ch 12: The Road Ahead](https://ainative.business/book/ch-12-the-road-ahead/) —: What the Case Studies Tell Us About the Future
- [Ch 13: The Wealth Manager](https://ainative.business/book/ch-13-the-wealth-manager/) —: When a Solo Founder Builds a Domain Application in a Day Using the Machine That Built Itself
- [Ch 14: The Meta-Program](https://ainative.business/book/ch-14-the-meta-program/) —: When the System You Are Using Is Also the System You Are Building

## Field Notes (56 articles)

Editorial log of building AI-native infrastructure on a workstation. Each article is a session transcript turned into a paper — covering training, fine-tuning, inference, RAG, agentic loops, observability, and dev tools.

- [№56 · The Refusal Floor Is Trainable — What a Frozen Curveball Proved About Prompts vs Weights](https://ainative.business/field-notes/the-refusal-floor-is-trainable/): A 30B model with a hand-tuned prompt contract refused 3 of 9 adversarial pretexts and fabricated private-looking state 3 times. A 4B trained for 21 minutes refused 9 of 9. The bench that saw the difference was frozen before training — and that discipline is the whole method.
- [№55 · The Meta-Program on a DGX Spark — When the Tool You Build With Is an Instance of the Thing You Build](https://ainative.business/field-notes/the-meta-program-on-spark/): The opener for the Machine-that-Builds-Machines arc. The book describes a meta-program on a SaaS platform; this is the same pattern on one personal box — a pane → hands → engine loop where the spec is the application and the skills are configuration over code.
- [№54 · The Machine Manages Its Own Memory — and the Bug the Mocks Slept Through](https://ainative.business/field-notes/the-machine-manages-its-own-memory/): Driving the Arena recall layer end-to-end on its own corpus: reindex → score → gate, dispatched through the control plane, recall@5 measured against 44 held-out questions. The first real drain caught a bug eight mock-injected unit tests had slept through — the case for operating the thing you built.
- [№53 · The Machine Improves Itself — Closed-Loop RLVR on a DGX Spark, Where the Eval Harness Is the Reward](https://ainative.business/field-notes/the-machine-improves-itself/): Closed-loop RLVR on one box: an eval→reward→fine-tune loop where the Spark's own verifiers ARE the reward — no learned reward model. The hero finding is defensive: pick the checkpoint on a frozen held-out split, never the training pool, or the loop reports success while it regresses.
- [№52 · The Gate Before the GPU — Deciding SFT vs RL vs RLVR Before You Spend the Run](https://ainative.business/field-notes/the-gate-before-the-gpu/): Building Kepler — a numeric astrodynamics reasoner — from scratch on one Spark. The method choice (SFT vs RL vs RLVR) is decided by cheap gates before any GPU run: a base preflight, an SFT gate, and a Goldilocks headroom gate. A flawless RLVR run that changed nothing is the proof.
- [№51 · Cost-Routing the Hermes Harness — When Local Stops Being Enough on a DGX Spark](https://ainative.business/field-notes/hermes-cost-routing-local-and-openrouter/): The local 30B-MoE on a Spark is at $0 marginal cost — until it isn't. H6 measures the failure-mode curve: where does local stop being enough, and what does the dollar curve look like when you escalate to OpenRouter only when you have to?
- [№50 · The Hermes Vertical Router on a DGX Spark — One Brain Always Warm, Five Specialists Summoned on Demand](https://ainative.business/field-notes/hermes-vertical-router-on-spark/): Five published Orionfold verticals plus the pinned MoE brain become a router on one Spark — not by parallel inference (the unified-memory envelope forbids that), but by a deterministic keyword classifier that dispatches the prompt and serves the right specialist one-at-a-time.
- [№49 · Picking the Hermes Brain on a DGX Spark — When Throughput Stops Being the Answer](https://ainative.business/field-notes/picking-the-hermes-brain-on-spark/): The Hermes serving-lane bakeoff couldn't pick a winner: all five lanes cleared the tool-call format bar. A graded brain-quality rubric breaks the tie — and shows the fastest serving lane is also the better agent, by a margin throughput could never have measured.
- [№48 · Hermes Drives the Spark via fieldkit-as-MCP — The Agent That Operates Its Own Machine](https://ainative.business/field-notes/hermes-drives-the-spark-via-fieldkit-mcp/): The keystone of the Harnesses series: expose a curated slice of fieldkit as MCP tools and the local Hermes agent can measure, quantize, publish, and retrieve on the box itself. The gate is a real llama-bench run the agent drove end-to-end — 0% tool-call format error, no API key.
- [№47 · Hardening the Hermes Harness on a DGX Spark — The Box Contains It, You Don't Trust the Model](https://ainative.business/field-notes/hardening-the-hermes-harness-on-spark/): Before you leave a tool-wielding agent running on your desk, harden it. One pure function turns Hermes' permissive defaults into a desk-grade posture, then a scripted hostile-tool-call test proves it: egress denied at the sandbox, secrets in .env only, the config surviving a restart.
- [№46 · The Hermes Serving Lane on a DGX Spark — MoE vs Dense, and the Number That Actually Picks the Lane](https://ainative.business/field-notes/hermes-serving-lane-on-spark/): Five Hermes serving lanes on one DGX Spark: Qwen3-30B-A3B MoE vs Qwen3-32B dense across vLLM, llama.cpp, and NIM. The MoE runs ~8.5× faster for the same memory — but the lane is picked by tool-call reliability, which took two config fights to get to 0% everywhere.
- [№45 · The Hermes Harness on a DGX Spark — A Local Cockpit That Holds Tools, With No API Key](https://ainative.business/field-notes/the-hermes-harness-on-spark/): Installing the Hermes agent harness on a DGX Spark and running the first local agent turn against the cached Nemotron-Nano-9B-v2 NIM — reliable tool calls, no API key, no cloud hop. The defensible angle is NIM-first; everyone else's Spark Hermes write-up leads with Ollama.
- [№44 · Two Trainers, One LoRA: NeMo Framework Beats Unsloth by 26% on a Patent-Strategist Fine-Tune](https://ainative.business/field-notes/patent-strategist-bakeoff-unsloth-vs-nemo-framework/): Same recipe, same R1-distilled base, same 5000-row patent corpus — once via Unsloth, once via NeMo Framework + Megatron-Bridge. NeMo finishes 26% faster and produces 44% longer patent-strategic chains. The cost is one YARN-defaults landmine and a stdout that lied for four hours.
- [№43 · Unsloth on the Spark — When the Train-Time Peak Equals the Base-Load Peak](https://ainative.business/field-notes/unsloth-on-spark-feasibility/): Six gates clear in one container against the v1 reset: pip install --no-deps preserves the s40 stack, FastLanguageModel loads at 16.94 GB peak, a 100-step LoRA train holds the same envelope, save_pretrained_gguf() emits both quants in 207 seconds end-to-end.
- [№42 · The Trainer Was Fine, the Corpus Wasn't: Three Misdiagnoses on a Patent-Specialist Fine-Tune](https://ainative.business/field-notes/fine-tune-data-prep-decisions-on-spark/): Five thousand rows of synthetic patent reasoning, two clean 131-minute LoRA trains, three rounds of confident diagnosis — and none of them found the bug. The bug was the corpus all along. A field report on the cheapest mistake to make on the Spark.
- [№41 · Three-Mode Bracket: Baselining a Reasoning Model Before Fine-Tuning, On One Spark](https://ainative.business/field-notes/patent-strategist-v1-baseline-on-spark/): Before you fine-tune a small reasoning model on a domain bench you need to know where it stands. Three context modes — closed, retrieval, oracle — triangulate the model's ceiling on one Spark, no Judge backend or cluster required.
- [№40 · Orionfold/II-Medical-8B-GGUF on Spark — five medical-reasoning variants, MedMCQA mini-eval, ChatML reasoning format](https://ainative.business/field-notes/becoming-a-medical-curator-on-spark/): Five GGUF variants of Intelligent-Internet/II-Medical-8B (Qwen3-8B + DAPO reasoning recipe) measured on a DGX Spark. Q5_K_M lands at 36.4 tok/s, 5.45 GB, and 52% on a MedMCQA n=50 mini-eval — above F16. First reasoning recipe in the series.
- [№39 · Orionfold/SecurityLLM-GGUF on Spark — five cyber variants, CyberMetric mini-eval, MCQ letter scoring](https://ainative.business/field-notes/becoming-a-cyber-curator-on-spark/): Five GGUF variants of ZySec-AI/SecurityLLM measured on a DGX Spark — Q4_K_M scores 40% on CyberMetric MCQ at 47.7 tok/s and 4.1 GB; the smaller variants matched or beat F16's 34%. Third vertical card; zero fieldkit source changes.
- [№38 · Orionfold/Saul-7B-Instruct-v1-GGUF on Spark — five legal variants, LegalBench mini-eval, four-axis measurement card](https://ainative.business/field-notes/becoming-a-legal-curator-on-spark/): Five GGUF variants of Equall/Saul-7B-Instruct-v1 measured on a DGX Spark — Q5_K_M scores 72% on LegalBench (n=50, contains) at 20 tok/s and 4.8 GB. Each card carries perplexity, sustained tok/s, thermal envelope, and a 5-task LegalBench subset score.
- [№37 · Orionfold/finance-chat-GGUF on Spark — five variants, FinanceBench mini-eval, four-axis measurement card](https://ainative.business/field-notes/becoming-a-gguf-publisher-on-spark/): Five GGUF variants of AdaptLLM/finance-chat measured on a DGX Spark — Q8_0 perplexity-matches F16 losslessly, Q4_K_M ships at 31 tok/s. Each card carries perplexity, sustained tok/s, thermal envelope, and FinanceBench accuracy.
- [№36 · Adaptive Turn Clipping on a Single Spark — A²TGPO, Studied from Source](https://ainative.business/field-notes/a2tgpo-turn-clipping-on-spark/): A²TGPO redesigns how Information Gain feeds GRPO: turn-group normalization, variance-rescaled accumulation, and adaptive turn-level clipping. The paper's release is the code; the Spark's contribution is the lineage primitive that records what each trial learned.
- [№35 · Reading the Lineage Primitive — cxcscmu Auto-Research, Studied from release_artifacts](https://ainative.business/field-notes/auto-research-loop-on-spark/): cxcscmu's own lineage_on vs lineage_off ablation closes the case: same agent, same trial budget, same prompt template — only the rendered lineage block differs, and the run with lineage produces 5.3× more keeps and 3.2× less wall-time waste. This piece extracts that primitive into fieldkit.lineage.
- [№34 · T²PO on Spark — When the Training Pool Says 28/32 and Held-out Says 9/158](https://ainative.business/field-notes/t2po-uncertainty-guided-rl-on-spark/): T²PO's two deltas on the Phase 6 ClawGym harness: mean turns 5.00 → 4.61, task_complete 154/158, but the per-assertion ceiling stays flat at 47.7%. The strongest training-side step (45) is the worst held-out checkpoint — pool saturation lies on a single Spark.
- [№33 · ClawGym GRPO on Spark — Closing the Loop the SFT Adapter Couldn't](https://ainative.business/field-notes/clawgym-on-spark-grpo/): Phase 5 SFT taught the agent to keep working but never to stop. 34 GRPO steps with a shaped reward unlearn the failure mode — same model, same base, same LoRA-init, but task_complete climbs 0/158 → 154/158, mean turns drop 12 → 5, and per-assertion still inches up +3.1 pp.
- [№32 · ClawGym on Spark — A 7B Base, A LoRA Adapter, and the +15 pp the Adapter Earned](https://ainative.business/field-notes/clawgym-on-spark/): ClawGym shipped only a .github profile, so we built the substrate ourselves — persona task synth, sandbox harness, 200-task corpus, LoRA SFT, matched-base eval. The adapter earns +3.8 pp task pass and +15.0 pp per-assertion against its own base. The diagnostic is the lift.
- [№31 · Pass@k After the Seventh Patch — Three Shapes ESamp Takes on Spark](https://ainative.business/field-notes/pass-at-k-after-the-seventh-patch/): Patches were six. The Pass@k harness surfaced a seventh — a one-line slice in the residual tap that only fires once batches shrink mid-run. Once cleared, ESamp takes three shapes: flat on saturated cells, lifting both rates on instruct headroom, and +6.67pp pass@8 on the unsaturated reasoning cell.
- [№30 · Two Patches Were Six — ESamp Lands at 97.4% on a Patched Spark](https://ainative.business/field-notes/runtime-frontier-six-patches-on-spark/): Article #2 closed at two patches. Applying them surfaced six — including the silent return-shape adapter that broke the consumer's port. Once cleared, ESamp lands at 97.4% of baseline on patched Qwen 2.5 7B, within 1.4 pp of the paper's reference.
- [№29 · Test-Time Distilling on Spark — Same Compute Envelope, Wider Semantic Reach](https://ainative.business/field-notes/test-time-distilling-for-exploration/): ESamp adds a tiny test-time-trained probe to vLLM that converts decoding from lexical resampling into semantic exploration. The runtime is vLLM-native — and that is a Spark catalog-gap story before it is a benchmark.
- [№28 · AutoResearchBench on Spark — Two NIMs, One Bench, Two Failure Modes](https://ainative.business/field-notes/autoresearchbench-on-spark/): Two Spark-tuned NIMs run AutoResearchBench's three Deep-Research example questions. Llama-3.1-8B crashes by turn 5-6 on its 8K context; Nemotron-Nano-9B-v2 finishes cleanly at 128K. Both score 0% Accuracy@1 — for completely different reasons.
- [№27 · Looking Beyond Spark — KV-Cache Arithmetic at Inference](https://ainative.business/field-notes/kv-cache-arithmetic-at-inference/): The serving memory bill is not weights. It's KV cache, and KV scales with concurrent users × context length, not parameters. Same four bills as training; different weights. A 70B at 32 users × 16k context wants 168 GB just for KV — and the Spark teaches you the per-token math.
- [№26 · Was the Agent Researching, or Flailing? An Observability Pass on the Trajectory](https://ainative.business/field-notes/trajectory-eval-is-the-agent-flailing/): A8 said the LoRA mode-collapsed because the trajectory was thin. This puts numbers on it: 6 of 13 knobs ever touched, 72% of proposals repeated a prior pair, and the proposer's k=5 history window is the structural cause.
- [№25 · Distilling the Architect — A 3B LoRA Trained on the Agent's Own Trajectory](https://ainative.business/field-notes/distill-architect-lora-from-trajectories/): A4's 50-iter trajectory becomes training data for a Qwen2.5-3B LoRA proposer. Holding out 8 iters, the 3B mode-collapses onto d_model=768 (the trajectory's most-frequent keep) and matches 0 / 8 exact; the 8B at T=0.5 matches 4 / 8 of its own past picks.
- [№24 · Derisking the Cloud Pretrain — How a $5K Spark Saves $50K on H100 Rentals](https://ainative.business/field-notes/derisk-cloud-pretraining-on-the-spark/): The Spark is too small for a serious pretrain — but it's the right size for the recipe-search that precedes one. Cull 100 candidate architectures down to 3 on one Spark for ~$1 of electricity, then book the cloud node knowing what to train. The expected savings per campaign run into the thousands.
- [№23 · What the Agent Actually Built — Five Articles in Plain English, and Why You Probably Don't Want to Train From Scratch](https://ainative.business/field-notes/what-the-agent-actually-built/): Five technical articles in one day built an unattended AI research loop on a desk for $0.02 of electricity. The plain-English readout: what the agent built (not a usable model), what it changes for one person, and a four-tier roadmap from LoRA in minutes to from-scratch in weeks.
- [№22 · The Autoresearch Loop — 50 Iterations of an LLM Editing Its Own Trainer Overnight](https://ainative.business/field-notes/autoresearch-agent-loop/): NIM Llama 3.1 8B drives a structured-perturbation agent loop against a 354M GPT pretrain. 50 iterations, 73.4 min wall, 0.07 kWh of electricity. 8 keeps, 42 reverts, 0 rail blocks, 0 crashes. Best result: val_bpb 10.8534, +0.93% over baseline at d_model=768.
- [№21 · Guardrails Before the Agent Edits — Code-Edit Policy as a Programmatic Funnel](https://ainative.business/field-notes/guardrails-for-code-generation/): Five programmatic rails between the Autoresearch agent's proposal and any mutation of train.py — schema, menu, range, cross-constraint, diff lint. 27 adversarial test cases: block recall 1.0, clean pass 1.0, every rail attribution correct. Zero LLM-as-judge calls.
- [№20 · The Data-Path Envelope — When Real Tokens Beat Random Tokens at Pretrain Throughput](https://ainative.business/field-notes/nemo-curator-training-data-prep/): Curator-cleaned wikitext-103 (109M tokens, 417 MiB packed) feeding the same 354M GPT pretrain loop from A2. Eight configs swept; data-path overhead is 0.01–0.04% across all of them. New peak: 14,980 tok/s — slightly above A2's random-token ceiling.
- [№19 · The GB10 Pretrain Envelope — Sweeping Batch, Sequence, and Precision on One Spark](https://ainative.business/field-notes/baseline-training-loop-on-spark/): Same 354M GPT, same training loop, swept across micro-batch (2,4,8,16), sequence length (1024,2048), and precision (bf16,fp8). 16 configurations, 30 steps each. Peak: 14,266 tokens/sec at batch=16, seq=1024, fp8 — 18% above the hand-rolled PyTorch baseline.
- [№18 · NeMo Framework on the Spark — What It Earns Over a Hand-Rolled train.py](https://ainative.business/field-notes/nemo-framework-on-spark/): Same 354M GPT, same 100 steps, same random tokens — once in a hand-rolled train.py against vanilla PyTorch, once via Megatron-Core inside the NeMo Framework container. Same hardware (GB10, 128 GB unified). The framework earns +5.8% throughput and 30% less GPU memory.
- [№17 · Second Brain as a Tool — Wrapping the RAG Stack in MCP for Claude Code](https://ainative.business/field-notes/mcp-second-brain-in-claude-code/): Closing the Second Brain arc. Four MCP tools wrap the RAG chain — embed, retrieve, optionally rerank, generate — and any Claude Code session anywhere on the box becomes a grounded research client. 200 lines of Python, one launcher, one .mcp.json entry.
- [№16 · Looking Beyond Spark — Fine-Tuning a 100B Nemotron](https://ainative.business/field-notes/gpu-sizing-math-for-fine-tuning/): A working answer to: how many GPUs to fine-tune a 100B Nemotron? Three methods, three memory footprints — full FT ≈ 1.6 TB needs 24× H100; LoRA ≈ 250 GB fits 8× H100; QLoRA ≈ 65 GB fits 1× H200. The Spark's 3B LoRA teaches the math.
- [№15 · Ragas, Reranked — What 44 Held-Out Questions Say About the Second Brain Stack](https://ainative.business/field-notes/rag-eval-ragas-and-nemo-evaluator/): A Ragas-style harness written in 200 lines of stdlib Python, run locally on the DGX Spark, against four variants of the Second Brain RAG chain. Naive RAG scores 3.30 / 5. Rerank RAG scores 4.27. LoRA+RAG is a surprise — it does not beat naive. Retrieval is where the points come from.
- [№14 · LoRA on Your Own Q&A — What 231 Pairs Actually Teach a 3B Model](https://ainative.business/field-notes/lora-on-your-own-qa-pairs/): 231 own-voice Q&A pairs, a rank-16 LoRA, 69 s of training on a GB10 Spark. The adapter won't memorize your exact numbers, but it will take a model that refuses 61% of questions about your work and turn it into one that answers all of them in your voice. For facts you still need RAG.
- [№13 · TensorRT-LLM on the Spark — FP8 Isn't the Reason to Drop NIM. NVFP4 Is.](https://ainative.business/field-notes/trtllm-and-triton-on-spark/): Dropping below NIM to raw TensorRT-LLM on a GB10 Spark. FP8 beats NIM's vLLM by 10-15% — barely worth the rebuild. NVFP4 beats it by 76% on decode, 43% on TTFT, and ships a 34%-smaller engine. The reason to drop NIM is the Blackwell-native 4-bit kernel, not FP8.
- [№12 · One Substrate, Three Apps — Where the Foundation Forks](https://ainative.business/field-notes/one-substrate-three-apps/): Seven articles installed one stack on the Spark — NIM, Embed, pgvector, RAG glue, reranker, generator A/B, Guardrails. This bridge retells that install as three different answers to one question — corpus plus 128 GB — and walks readers to the top of three tracks.
- [№11 · One Rail, Three Policies — NeMo Guardrails on the Retrieval Path](https://ainative.business/field-notes/guardrails-on-the-retrieval-path/): NeMo Guardrails drops a policy gate between retrieval and generation. One install, three per-arc configs — PII for Second Brain, style for LLM Wiki, code-safety for Autoresearch — and a 15-query benchmark: 100% block recall, 100% clean pass. Rails are scaffolding; detectors are the content.
- [№10 · Bigger Generator, Same Grounding — 8B vs 49B vs 70B on One Retrieval Chain](https://ainative.business/field-notes/bigger-generator-grounding-on-spark/): The rerank-and-fusion article bet that a bigger generator would heal the 8B Google-IPO refusal. Ran the A/B across three sizes on one retrieval chain. Bet lost: Nemotron-Super-49B over-refuses the 8B baseline; Llama 3.3 70B narrows the gap, not closes it. The refusal was the scaffold working.
- [№09 · Hybrid Retrieval on the Spark — BM25, Dense, Fusion, Rerank](https://ainative.business/field-notes/rerank-fusion-retrieval-on-spark/): Four retrieval modes on one corpus — naive dense, BM25, Reciprocal Rank Fusion, Nemotron rerank. Dense is already 92% recall@5; rerank adds a point at K=10 and reorders the top. The 8B generator still refuses where retrieval is perfect — grounding, not retrieval, is the new bottleneck.
- [№08 · Three Endpoints, One Answer — Naive RAG on a DGX Spark](https://ainative.business/field-notes/naive-rag-on-spark/): Three endpoints in one curl chain — a query embeds through Nemotron, pgvector returns top-5 chunks in under 80 ms, and a Llama 3.1 8B NIM stuffs them into a strict-context prompt. The chain works; the 8B generator still refuses on questions its own context answers.
- [№07 · Where Your Vectors Live — pgvector on a DGX Spark](https://ainative.business/field-notes/pgvector-on-spark/): The substrate between the embed call and the retrieve call — pgvector 0.8.2 running as a Postgres 16 container on GB10, with 1000 Nemotron vectors, HNSW and ivfflat both indexed, and a planner that prefers seq scan until you tell it otherwise.
- [№06 · Your Own Semantic Space — a Nemotron Embedding NIM on a DGX Spark](https://ainative.business/field-notes/nemo-retriever-embeddings-local/): The embedding endpoint that every downstream RAG, wiki, and agent piece will reuse — a 2048-dim Nemotron Retriever NIM running locally on GB10, ready 52 seconds after docker run and holding 28 docs/s under batched load.
- [№05 · Your First NIM on a DGX Spark — What 24.8 Tokens Per Second Doesn't Tell You](https://ainative.business/field-notes/nim-first-inference-dgx-spark/): First-contact notes on NVIDIA's DGX-Spark-specific Llama 3.1 8B NIM. 9.4 GB image, ~108 s warm-cache cold-start, 24.8 tok/s steady, OpenAI-compatible on :8000 — and a confidently wrong Python one-liner that clarifies what small-model FP8 buys and what it costs.
- [№04 · The Sandbox Tax That Wasn't — NemoClaw vs OpenClaw on One DGX Spark](https://ainative.business/field-notes/nemoclaw-vs-openclaw-dgx-spark/): I ran NemoClaw's sandboxed agent stack and the host Ollama-OpenClaw CLI side by side on one DGX Spark with the same 123B Nemotron model. The sandbox overhead I went looking for is real but modest (~2× raw inference); the real tax is onboarding, and NemoClaw paid it at install time.
- [№03 · Access First, Models Second — How I Set Up My DGX Spark for Solo AI Work](https://ainative.business/field-notes/dgx-spark-day-one-access-first/): Most DGX Spark walkthroughs open with CUDA and tokens/sec. This one opens with streaming, AI-pair-programming, sandboxed agents, and browser automation — the access layer. For a solo edge builder, that interaction stack is more load-bearing than the model stack.
- [№02 · Case Study: Building a Domain Application in One Day with AI Agent Infrastructure](https://ainative.business/field-notes/solo-builder-case-study/): A single-day, verifiable build of a full wealth-management application — prediction-market integration, divergence detection, scenario modeling, and conviction synthesis — entirely on ainative-business primitives. 7,435 lines of domain code built on 31k–57k lines of inherited platform. Every metric traceable to a specific git commit.
- [№01 · AI Transformation Research: Building and Governing AI-Native Businesses](https://ainative.business/field-notes/ai-transformation/): How solo founders, agencies, and PE firms build AI-native businesses with governed agent orchestration. A market-sizing, governance, and competitive-landscape analysis of the $7.63B→$52.62B agent economy, the 80–90% production failure rate, and the structural gap no platform currently fills.

## Source Code

- [GitHub Repository](https://github.com/orionfold/ainative)

## Optional

- [Sitemap](https://ainative.business/sitemap-index.xml)
- [RSS feed](https://ainative.business/feed.xml/): All field notes + book chapters
- [JSON Feed](https://ainative.business/feed.json/): Modern alternative to RSS
- [llms-full.txt](https://ainative.business/llms-full.txt): Long-form, citation-friendly site overview for AI agents