# ainative — Companion Software for AI Native Business

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

URL: https://ainative.business
License: Apache 2.0
Status: Pre-alpha (active development)
Author: Manav Sehgal
Author URL: https://www.linkedin.com/in/manavsehgal/
GitHub: https://github.com/orionfold/ainative

---

## Project Overview

ainative is the companion software to the AI Native Business book — a 14-chapter playbook for building autonomous business systems as a solo or small-team operator. The book lays out the principles; ainative is the working scaffold readers can study, run locally, and extend.

### What ainative Provides

- A goal-oriented, persistent, memory-native multi-agent execution scaffold readers can install, inspect, and modify.
- A reference implementation of the architectural patterns described in the book — task graphs, hierarchical memory, graduated autonomy, multi-model routing.
- A local-first runtime (Tauri-based desktop) with cloud-optional reach, so readers can run the same task graph on their machine or push it to elastic compute.

### Five Differentiation Pillars

1. **Long-Horizon Task Persistence** — Tasks that span hours, days, or weeks. Checkpoint/resume, progress tracking, failure recovery, and resource budgets.
2. **Multi-Model Orchestration** — Route subtasks to the best available model. Claude for reasoning, GPT for long-context, Gemini for research, Grok for speed, open-source via Ollama for cost control and privacy.
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, per-task-type, per-risk-level.
5. **Hybrid Execution** — Desktop-native with cloud reach. Same task graph runs locally or in the cloud with state portability.

### Technology Stack

- **Backend**: Rust (Tauri), WASM sandboxing (Wasmtime), SQLite (rusqlite)
- **Frontend**: TypeScript, React, React Flow (task DAG canvas)
- **Protocols**: MCP, A2A, CDP, WebMCP, Tauri IPC, WebSocket
- **AI Providers**: Anthropic Claude, OpenAI, Google Gemini, Ollama

---

## Author

**Manav Sehgal** is a Solutions Leader at AWS Frontier AI, collaborating with Anthropic, NVIDIA, and Disney on production AI and agentic systems. His 25-year arc spans Xerox PARC (1996), HCL's digital practice, Daily Mail, Amazon AGI, and AWS. He led AWS's pandemic response which received the President of India award. He holds credentials from Harvard, MIT Sloan, and UC Berkeley Haas, and has 2M+ Kaggle dataset views. He has previously published *Data Science Solutions* (2017) and *React Speed Coding* (2015).

Profiles:
- LinkedIn: https://www.linkedin.com/in/manavsehgal/
- GitHub: https://github.com/manavsehgal
- X / Twitter: https://x.com/manavsehgal
- Kaggle: https://www.kaggle.com/manavsehgal

---

## Book — AI Native Business

A 14-chapter playbook for autonomous business systems. License: Creative Commons BY-NC. Free to read online.


### Part 1 — The Blueprint

#### Chapter 1: From Hierarchy to Intelligence
*Two Thousand Years of Organizational Design — and Why It's About to Break*

Reading time: ~15 min · 3866 words
URL: https://ainative.business/book/ch-1-from-hierarchy-to-intelligence/

#### Chapter 2: The AI-Native Blueprint
*From Factory Metaphor to Working Architecture*

Reading time: ~12 min · 3050 words
URL: https://ainative.business/book/ch-2-the-ai-native-blueprint/


### Part 2 — The Factory

#### Chapter 3: The Refinery
*From Intent to Structured Work*

Reading time: ~15 min · 2379 words
URL: https://ainative.business/book/ch-3-the-refinery/

#### Chapter 4: The Forge
*Task Execution at Scale*

Reading time: ~16 min · 2907 words
URL: https://ainative.business/book/ch-4-the-forge/

#### Chapter 5: Blueprints
*Workflow Orchestration*

Reading time: ~14 min · 2560 words
URL: https://ainative.business/book/ch-5-blueprints/

#### Chapter 6: The Arena
*Scheduled Intelligence*

Reading time: ~12 min · 2710 words
URL: https://ainative.business/book/ch-6-the-arena/


### Part 3 — The Network

#### Chapter 7: Institutional Memory
*The Knowledge Graph*

Reading time: ~14 min · 2518 words
URL: https://ainative.business/book/ch-7-institutional-memory/

#### Chapter 8: The Swarm
*Multi-Agent Coordination*

Reading time: ~16 min · 2700 words
URL: https://ainative.business/book/ch-8-the-swarm/

#### Chapter 9: The Governance Layer
*Trust at Scale*

Reading time: ~13 min · 3392 words
URL: https://ainative.business/book/ch-9-the-governance-layer/


### Part 4 — The Vision

#### Chapter 10: The World Model
*From Project State to Organizational Intelligence*

Reading time: ~15 min · 2699 words
URL: https://ainative.business/book/ch-10-the-world-model/

#### Chapter 11: The Machine That Builds Machines
*ainative-business Building Itself Using Itself*

Reading time: ~14 min · 3395 words
URL: https://ainative.business/book/ch-11-the-machine-that-builds-machines/

#### Chapter 12: The Road Ahead
*What the Case Studies Tell Us About the Future*

Reading time: ~10 min · 2416 words
URL: https://ainative.business/book/ch-12-the-road-ahead/

#### Chapter 13: The Wealth Manager
*When a Solo Founder Builds a Domain Application in a Day Using the Machine That Built Itself*

Reading time: ~16 min · 3976 words
URL: https://ainative.business/book/ch-13-the-wealth-manager/

#### Chapter 14: The Meta-Program
*When the System You Are Using Is Also the System You Are Building*

Reading time: ~16 min · 4352 words
URL: https://ainative.business/book/ch-14-the-meta-program/

---

## Field Notes (56 articles)

Editorial log: session transcripts turned into papers. Topics span training, fine-tuning, inference, RAG, agentic systems, observability, deployment, and dev tooling. Almost all articles document hands-on experiments on the NVIDIA DGX Spark workstation.

### №56 · The Refusal Floor Is Trainable — What a Frozen Curveball Proved About Prompts vs Weights

**Stage:** fine-tuning
**Series:** Machine that Builds Machines
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~16 min read — synthesis of a two-day advisor build on one Spark
**Tags:** sft, refusal, grounded-citation, ood-evaluation, curveball-bench, nemotron, advisor, machine-that-builds-machines, dgx-spark
**Published:** 2026-06-10
**URL:** 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

**Stage:** agentic
**Series:** Machine that Builds Machines
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~15 min read — no setup; a synthesis of work already shipped on this box
**Tags:** meta-program, machine-that-builds-machines, agentic, configuration-over-code, fieldkit, recursion, dgx-spark
**Published:** 2026-06-02
**URL:** 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

**Stage:** observability
**Series:** Second Brain
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~4 hours end-to-end — bring up the cockpit, drive a reindex + two RAG-evals through the control plane, score 44 questions, and ship the artifact
**Tags:** second-brain, rag, recall, provenance, pgvector, arena, control-plane, dogfood, observability, dgx-spark, fieldkit
**Published:** 2026-06-03
**URL:** 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

**Stage:** fine-tuning
**Series:** Machine that Builds Machines
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~16 min read — a synthesis of a proven run plus the engine it became
**Tags:** rlvr, grpo, reinforcement-learning, fine-tuning, machine-that-builds-machines, fieldkit, dgx-spark
**Published:** 2026-06-03
**URL:** 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

**Stage:** fine-tuning
**Series:** Machine that Builds Machines
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~18 min read — synthesis of a multi-day greenfield-vertical build on one Spark
**Tags:** rlvr, sft, grpo, method-selection, reinforcement-learning, fine-tuning, machine-that-builds-machines, dgx-spark
**Published:** 2026-06-05
**URL:** 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

**Stage:** agentic
**Series:** Harnesses
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark + OpenRouter API (~$5 budget)
**Difficulty:** intermediate
**Time:** ~4 hours including the OpenRouter bakeoff + harness publish
**Tags:** hermes, agentic, routing, cost, openrouter, frontier, dgx-spark, qwen3, claude-opus
**Published:** 2026-05-28
**URL:** 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

**Stage:** agentic
**Series:** Harnesses
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~3 hours including bakeoff + harness publish
**Tags:** hermes, agentic, routing, multi-domain, llama-cpp, qwen3, orionfold, dgx-spark
**Published:** 2026-05-28
**URL:** 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

**Stage:** agentic
**Series:** Harnesses
**Product:** NIM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~6 hours across three serving lanes, N=5 attempts per prompt
**Tags:** hermes, evaluation, agentic, qwen3, moe, llama-cpp, vllm, nim, brain-quality, tool-calling, dgx-spark
**Published:** 2026-05-28
**URL:** 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

**Stage:** agentic
**Series:** Harnesses
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~3 hours, including the live tool-call gate against a local NIM
**Tags:** hermes, agentic, mcp, fieldkit, tool-calling, local-first, agentskills, dgx-spark
**Published:** 2026-05-26
**URL:** 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

**Stage:** agentic
**Series:** Harnesses
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~2 hours, most of it the hostile-tool-call containment battery
**Tags:** hermes, agentic, hardening, sandbox, security, tool-calling, local-first, dgx-spark
**Published:** 2026-05-26
**URL:** 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

**Stage:** deployment
**Series:** Harnesses
**Product:** NIM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~3 hours, most of it model pulls and four cold-starts
**Tags:** hermes, vllm, llama-cpp, nim, qwen3, moe, tool-calling, dgx-spark
**Published:** 2026-05-26
**URL:** 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

**Stage:** agentic
**Series:** Harnesses
**Product:** NIM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~1 hour, most of it the NIM's first cold-start
**Tags:** hermes, nim, nemotron, agentic, tool-calling, local-first, mcp, dgx-spark
**Published:** 2026-05-26
**URL:** 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

**Stage:** fine-tuning
**Series:** Looking Beyond Spark
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~16 hours wall (7h 34m Unsloth + 5h 38m NeMo + conversion + merge + probe)
**Tags:** fine-tuning, lora, sft, nemo-framework, unsloth, megatron-bridge, deepseek-r1, patent-strategist, dgx-spark, looking-beyond-spark
**Published:** 2026-05-21
**URL:** 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

**Stage:** fine-tuning
**Series:** Machine that Builds Machines
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~1 hour (one container, six gates, two GGUFs)
**Tags:** fine-tuning, lora, unsloth, nemotron, llama-cpp, gguf, peft, gradient-checkpointing, mtbm, dgx-spark
**Published:** 2026-05-19
**URL:** 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

**Stage:** fine-tuning
**Series:** Machine that Builds Machines
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~12 hours (2× 131-min trains + diagnosis)
**Tags:** fine-tuning, lora, sft, trl, r1-distill, patent-strategist, data-prep, corpus-quality, deep-seek, dgx-spark
**Published:** 2026-05-19
**URL:** 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

**Stage:** fine-tuning
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~10 hours (mostly automated overnight sweeps)
**Tags:** eval, rag, reasoning-models, llama-cpp, deepseek-r1, vertical-bench, patent-strategist
**Published:** 2026-05-17
**URL:** 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

**Stage:** deployment
**Series:** Machine that Builds Machines
**Product:** llama.cpp
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~5 hours end-to-end on a DGX Spark
**Tags:** gguf, quantization, medical, healthcare, orionfold, medmcqa, qwen3, chatml, reasoning, fieldkit, spark-tested
**Published:** 2026-05-16
**URL:** 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

**Stage:** deployment
**Series:** Machine that Builds Machines
**Product:** llama.cpp
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~5 hours end-to-end on a DGX Spark
**Tags:** gguf, quantization, cyber, security, orionfold, cybermetric, mistral, zephyr, fieldkit, spark-tested
**Published:** 2026-05-15
**URL:** 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

**Stage:** deployment
**Series:** Machine that Builds Machines
**Product:** llama.cpp
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~5 hours end-to-end on a DGX Spark
**Tags:** gguf, quantization, legal, orionfold, legalbench, mistral, fieldkit, spark-tested
**Published:** 2026-05-14
**URL:** 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

**Stage:** deployment
**Series:** Machine that Builds Machines
**Product:** llama.cpp
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~6 hours end-to-end on a DGX Spark
**Tags:** gguf, quantization, finance, orionfold, financebench, llama-2-chat, fieldkit, spark-tested
**Published:** 2026-05-14
**URL:** 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

**Stage:** fine-tuning
**Series:** Machine that Builds Machines
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~30 min read
**Tags:** reinforcement-learning, grpo, agentic, credit-assignment, information-gain, qwen, verl, fieldkit, lineage, machine-that-builds-machines
**Published:** 2026-05-11
**URL:** 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

**Stage:** agentic
**Series:** Machine that Builds Machines
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~28 min read
**Tags:** agentic, autoresearch, multi-agent, lineage, fieldkit, claude-agent-sdk, machine-that-builds-machines
**Published:** 2026-05-10
**URL:** 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

**Stage:** fine-tuning
**Series:** Frontier Scout
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~18.5 hours wall (50 T²PO steps + three evals)
**Tags:** agentic, fine-tuning, lora, peft, rl, grpo, gigpo, t2po, exploration
**Published:** 2026-05-09
**URL:** 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

**Stage:** fine-tuning
**Series:** Frontier Scout
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~9 hours wall (34 GRPO steps + two evals)
**Tags:** agentic, fine-tuning, lora, peft, rl, grpo, reinforce, vllm
**Published:** 2026-05-05
**URL:** 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

**Stage:** fine-tuning
**Series:** Frontier Scout
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~3 days end-to-end (mostly waiting on rollouts)
**Tags:** agentic, sandboxing, fine-tuning, lora, peft, rl, grpo, sft, vllm, nim
**Published:** 2026-05-05
**URL:** 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

**Stage:** inference
**Series:** Frontier Scout
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~3 hours of measurement · ~one line of patch
**Tags:** decoding, sampling, test-time-scaling, vllm, runtime, patching, benchmarks, pass-at-k, aime, humaneval
**Published:** 2026-05-03
**URL:** 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

**Stage:** inference
**Series:** Frontier Scout
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~2 hours of patching · ~30 minutes of measuring
**Tags:** decoding, sampling, test-time-scaling, vllm, runtime, patching, benchmarks
**Published:** 2026-05-03
**URL:** 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

**Stage:** inference
**Series:** Frontier Scout
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~2 hours — most of it watching vLLM 0.20 build inside an NGC PyTorch container; the runtime+drift diagnosis that follows is the short, sharp half
**Tags:** decoding, sampling, test-time-scaling, reasoning, distillation, vllm, runtime
**Published:** 2026-05-02
**URL:** 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

**Stage:** observability
**Series:** Frontier Scout
**Product:** NIM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~3 hours — 30 min plumbing, ~20 min for the runs themselves, the rest is reading what they show
**Tags:** agentic, benchmark, retrieval, literature-search, nim, evaluation, autoresearch
**Published:** 2026-05-02
**URL:** 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

**Stage:** foundations
**Series:** Looking Beyond Spark
**Product:** TensorRT-LLM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~22 minute read
**Tags:** inference, kv-cache, paged-attention, fp8, gqa, h100, h200, b200, dgx-spark
**Published:** 2026-04-30
**URL:** 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

**Stage:** observability
**Series:** Machine that Builds Machines
**Product:** NIM Llama 3.1 8B
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~2 hours wall — analysis runs in seconds, the rest is reading + writing
**Tags:** observability, agentic, autoresearch, evaluation, llm-agents, prompt-engineering
**Published:** 2026-05-01
**URL:** 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

**Stage:** fine-tuning
**Series:** Machine that Builds Machines
**Product:** NeMo Customizer
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~2 hours wall — 4 min LoRA training, 4 min race, the rest writing
**Tags:** fine-tuning, lora, distillation, autoresearch, peft, qwen2.5, dgx-spark
**Published:** 2026-05-01
**URL:** 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

**Stage:** training
**Series:** Looking Beyond Spark
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~30 minute read · math + economics, no GPU required
**Tags:** training, pretrain, cloud, h100, h200, beyond-spark, autoresearch, dgx-spark, economics
**Published:** 2026-04-30
**URL:** 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

**Stage:** foundations
**Series:** Looking Beyond Spark
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** beginner
**Time:** ~15 minute read · no GPU required
**Tags:** foundations, training, layman, autoresearch, dgx-spark, roadmap, lora, fine-tuning, pretrain
**Published:** 2026-04-25
**URL:** 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

**Stage:** agentic
**Series:** Machine that Builds Machines
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~3 hours — 90 min to scaffold the loop, 73 min for the unattended run, the rest is reading the trajectory
**Tags:** agentic, autoresearch, nemo, nim, llama, megatron, dgx-spark, training, agent-loop
**Published:** 2026-04-25
**URL:** 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

**Stage:** agentic
**Series:** Machine that Builds Machines
**Product:** NeMo Guardrails
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~2 hours — 30 min for the perturbation menu + structured proposal schema, 60 min for the 5 rails + 27-case adversarial bench, 30 min to write up
**Tags:** guardrails, nemo-guardrails, agentic, autoresearch, code-edit, policy, dgx-spark
**Published:** 2026-04-25
**URL:** 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

**Stage:** training
**Series:** Machine that Builds Machines
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~2 hours — 5 min for the corpus pull, 45 min for a derived container build, 2 min for the Curator pipeline + 40s tokenize, 3 min for the 8-config sweep, the rest is reading the numbers
**Tags:** nemo, nemo-curator, training, pretrain, data-prep, tokenization, autoresearch, dgx-spark
**Published:** 2026-04-25
**URL:** 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

**Stage:** training
**Series:** Machine that Builds Machines
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~30 min once the NeMo container is on disk — 7.4 min wall for the 16-config sweep, the rest is reading the numbers
**Tags:** nemo, training, pytorch, transformer-engine, fp8, megatron, autoresearch, dgx-spark, throughput
**Published:** 2026-04-25
**URL:** 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

**Stage:** training
**Series:** Machine that Builds Machines
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~3 hours — 90 min for two container pulls (PyTorch 30 GB, NeMo Framework Megatron Backend 70 GB), 30 min for the matched scripts, 10 min for the two pretrain runs and analysis
**Tags:** nemo, training, pytorch, pretrain, gpt, autoresearch, dgx-spark, megatron
**Published:** 2026-04-25
**URL:** 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

**Stage:** agentic
**Series:** Second Brain
**Product:** NIM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~90 minutes — 30 min to design the tool surface, 30 min to wire FastMCP + pgvector, 15 min to register with Claude Code, 15 min for the demo and trace
**Tags:** mcp, claude-code, second-brain, rag, agentic, fastmcp, pgvector, nim, dgx-spark
**Published:** 2026-04-24
**URL:** 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

**Stage:** foundations
**Series:** Looking Beyond Spark
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~25 minute read
**Tags:** fine-tuning, memory, sizing, lora, qlora, fsdp, nemotron, h100, h200, dgx-spark
**Published:** 2026-04-23
**URL:** 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

**Stage:** observability
**Series:** Second Brain
**Product:** NeMo Evaluator
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~60 minutes end-to-end — 40 s to ingest the blog into pgvector, 2 min for retrieval, 4 min for generation across three 8B variants, 90 s for the LoRA variant, 9 min for grading
**Tags:** ragas, nemo-evaluator, evaluation, rag, retrieval, rerank, second-brain, observability, dgx-spark
**Published:** 2026-04-23
**URL:** 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

**Stage:** fine-tuning
**Series:** Second Brain
**Product:** Hugging Face PEFT + Qwen2.5-3B-Instruct
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~45 minutes end-to-end — 5 min corpus via NIM 8B, 69 s training, 3 min benchmark, plus a 6 GB base-model download
**Tags:** fine-tuning, lora, peft, qwen, second-brain, dgx-spark
**Published:** 2026-04-23
**URL:** 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.

**Stage:** deployment
**Series:** Second Brain
**Product:** TensorRT-LLM + Triton Inference Server
**Hardware:** NVIDIA DGX Spark
**Difficulty:** advanced
**Time:** ~4 hours including two container pulls and three engine builds
**Tags:** deployment, tensorrt-llm, triton, trtllm-serve, fp8, nvfp4, blackwell, gb10, second-brain, dgx-spark
**Published:** 2026-04-23
**URL:** 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

**Stage:** foundations
**Series:** Foundations
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** 10-minute read; no hands-on
**Tags:** foundation, second-brain, llm-wiki, autoresearch, arc, bridge, dgx-spark
**Published:** 2026-04-22
**URL:** 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

**Stage:** inference
**Series:** Foundations
**Product:** NeMo Guardrails
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~90 minutes on top of the rerank-fusion / bigger-generator chain
**Tags:** guardrails, nemo, rag, rails, colang, policy, pii, second-brain, llm-wiki, autoresearch, dgx-spark
**Published:** 2026-04-22
**URL:** 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

**Stage:** inference
**Series:** Foundations
**Product:** Llama 3.3 70B + Nemotron-Super-49B + Llama 3.1 8B NIM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~30 minutes on top of the rerank-and-fusion chain
**Tags:** rag, grounding, refusal, nemotron, llama, generator, scale, dgx-spark
**Published:** 2026-04-22
**URL:** 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

**Stage:** inference
**Series:** Foundations
**Product:** Nemotron Reranker + pgvector full-text + Llama 3.1 8B NIM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~45 minutes on top of the naive-RAG chain
**Tags:** rag, retrieval, rerank, bm25, rrf, hybrid, nemotron, pgvector, fusion, dgx-spark
**Published:** 2026-04-22
**URL:** 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

**Stage:** inference
**Series:** Foundations
**Product:** Llama 3.1 8B NIM + Nemotron Retriever + pgvector
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~30 minutes if the three endpoints are already warm
**Tags:** rag, retrieval, llama, nemotron, pgvector, nim, grounding, hallucination, dgx-spark
**Published:** 2026-04-22
**URL:** 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

**Stage:** inference
**Series:** Foundations
**Product:** pgvector
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~15 minutes first install, re-runs in seconds
**Tags:** pgvector, postgres, hnsw, ivfflat, matryoshka, nemotron, retrieval, dgx-spark
**Published:** 2026-04-22
**URL:** 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

**Stage:** inference
**Series:** Foundations
**Product:** NeMo
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~30 minutes first install, ~1 minute every restart after
**Tags:** nemo-retriever, embeddings, nim, matryoshka, retrieval, nemotron, dgx-spark
**Published:** 2026-04-22
**URL:** 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

**Stage:** inference
**Series:** Foundations
**Product:** NIM
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~2 hours first install, ~2 minutes every restart after
**Tags:** nim, ngc, inference, llama, fp8, vllm, first-contact, dgx-spark
**Published:** 2026-04-22
**URL:** 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

**Stage:** agentic
**Product:** NemoClaw
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~2 hours after prerequisites
**Tags:** agentic, nemoclaw, openclaw, ollama, sandboxing, nemotron, claude-code, personal-ai, solo-builder
**Published:** 2026-04-21
**URL:** 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

**Stage:** foundations
**Product:** Foundation
**Hardware:** NVIDIA DGX Spark
**Difficulty:** intermediate
**Time:** ~6 hours spread across a week
**Tags:** foundations, interaction-stack, remote-access, agentic, personal-ai, solo-builder, claude-code
**Published:** 2026-04-21
**URL:** 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

**Stage:** foundations
**Series:** AI Native Platform
**Product:** ainative
**Difficulty:** intermediate
**Time:** 22 min read
**Tags:** ai-native-platform, case-study, solo-founder, prediction-markets, wealth-management, applied-research, ainative-business
**Published:** 2026-04-07
**URL:** 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

**Stage:** foundations
**Series:** AI Native Platform
**Product:** ainative
**Difficulty:** intermediate
**Time:** 22 min read
**Tags:** ai-native-platform, agentic-economy, governance, market-analysis, solo-founder, agency, private-equity
**Published:** 2026-03-01
**URL:** 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.

---

## How to Cite

When citing ainative content, please use the canonical URL on https://ainative.business and credit Manav Sehgal as author. Articles are released under Creative Commons BY-NC 4.0 unless noted otherwise; the companion software is Apache 2.0.

Suggested citation format:

> Sehgal, M. (YYYY). *<Article Title>*. AI Native Field Notes. Retrieved from <URL>