Rohn Springfield
Get in touch

AI Engineer & Data Scientist · Raleigh, NC

Data science. Intelligent systems. Products that ship.

I turn complex data and ambitious ideas into intelligent, reliable software, and I own the work from the first question to the running system.

See the products Start a conversation Résumé
8
products shipped since 2025
690K+
lines of code, public repos
10+
years, finance → data → AI
Built with
  • Python
  • TypeScript
  • SQL
  • Next.js
  • React
  • FastAPI
  • Fastify
  • PostgreSQL
  • Kubernetes
  • Docker
  • Lean 4
  • iOS · Android
  • Tableau
  • LLM APIs
  • Claude
  • Codex
  • Cursor
  • MCP
BLERBZ · The Weekend Whippersnapper A weekly feature issue generated from the week's coverage: one focus story, a look back, a rundown, and a listening mode that reads it aloud. Web, iOS, AndroidAutonomous pipeline
1 / 12

Featured products & projects

Real products, engineered end to end.

Eight products shipped since late 2025 and a body of analytics work behind them; each one owned from the first question through tests, packaging and deployment. Every screenshot below is the actual interface.

The Weekend Whippersnapper: a weekly feature issue with a focus story, a look back and a rundown, with a listening mode.
BLERBZ 100: the day's ranked stories. Elite 5 in focus, with source, age and a one-paragraph brief.
Window: the main feed, mixing publishers, Tubes and podcasts into one ranked wall.
Local: top stories by US region, with the lead story as a full-bleed banner.
Paper: The Daily Blerb, a broadsheet front page rendered from the day's feed. Classic and Modern layouts.
Paper: additional coverage in classic column typesetting, all generated from live stories.
Toons: today's editorial cartoons, generated from top stories, with a live ticker.
Top Tubes: ranked video from tracked channels, filterable by videos and shorts.
1 / 8
01

BLERBZ

Your window into the news.

Live · web, iOS and Android · founded Nov 2025

The problem

Keeping up with the news means reading more than anyone can, from sources of uneven quality, in formats that were never designed to be scanned, listened to or compared. Most aggregators stop at a list of links.

The product

BLERBZ ingests fresh headlines and images from tracked publishers and channels, filters and tags them with AI, ranks them into a daily 100, and renders the same stories into many surfaces: a swipeable card feed, region maps, a broadsheet newspaper, a weekly feature issue, editorial cartoons, a video wall and an audio playlist. ARTEMIZ, the newsroom agent, turns any story into a brief, a storyboard or a broadcast-ready clip. The whole operation runs with minimal manual oversight.

  • BLERBZ 100: a daily ranked list with an Elite 5 and Top 20, each with TLDR and context
  • Global and Local: stories plotted on world and US maps, filterable by region
  • Window, Markets, Top Tubes and Vibes: feed, finance, video and sound surfaces on the same data
  • Paper: The Daily Blerb, a broadsheet generated from the feed with Classic and Modern layouts
  • The Weekend Whippersnapper: a weekly feature issue with a listening mode
  • Toons: editorial cartoons generated daily from top stories
  • Listen: every story read aloud with selectable voices; a 30-story audio playlist
  • ARTEMIZ newsroom agent: news brief, cartoon, storyboard, meme pack, anchor scene, story-to-stream
  • Production web app plus native iOS and Android apps
Architecture & implementation
  • Pipeline: source content → fresh headlines and images → AI filtering and tagging → topic labels → card collage → card detail
  • Autonomous operations across ingestion, story ranking, AI enrichment and media production, running continuously
  • Multi-agent newsroom (ARTEMIZ) with a shared agent system prompt covering reasoning, memory, tool use and editorial quality
  • Media generation pipelines for cartoons, anchor scenes and video; text-to-speech for story audio
  • Runs on dedicated AI hardware (NVIDIA DGX Spark) operated by the founder; see Labzilla for the platform layer
  • Architecture, implementation, testing and release owned end to end
  • TypeScript
  • Python
  • iOS
  • Android
  • LLM APIs
  • Agent orchestration
  • Text-to-speech
  • Image & video generation
  • DGX Spark
  • AI
  • Data
  • Software
  • Experience
  • Infrastructure
Media Performance: weekly check-in with sales, views and impressions against the prior 13 weeks, paid vs organic mix, channel mix and division performance.
Open Dependency Risk: 1,500 npm and PyPI packages; known vulnerabilities, risk flags, GitHub advisory severity, release freshness on a log scale and an ecosystem-to-severity exposure flow.
Global Water Resources: FAO AQUASTAT for 197 countries; withdrawal by sector, SDG 6.4.2 stress bands, a stress map, largest withdrawals, data provenance flags and safe drinking water.
World Economy Stats: IMF and World Bank measures for 217 countries on a hex map with per-continent callouts, percentile comparisons, highest and lowest in view, and ranked bars by continent.
Open Source Developer AI Productivity: METR's randomized study; issues, developers and hours, the effect of AI on completion time with 95% intervals by cohort, and monthly activity.
Superstore Executive Summary: FY2026 vs FY2025 KPIs with sparklines, monthly sales against prior-year markers, a state bubble map, sub-category and customer rankings.
Supply Chain Dashboard: orders, shipping time, on-time rate and margin, with order status by segment, a peak-order-time heatmap and delivery status by ship mode.
SaaS Support, Channel Performance: five channels side by side; tickets, region hexmaps, top issue types, CSAT, sentiment, resolution time and status.
Startup Venture Funding: rounds and capital vs prior year, a funding funnel, capital by market, round mix, funding by country and time-to-raise distributions.
Outdoor Gear E-Commerce KPIs: revenue, return rate, orders and gross margin for one month by channel and category, with YTD comparisons.
Workforce Admin: headcount, performance, attrition and salary hike with tenure rings, plus top roles, education fields and sales performers.
Pipeline Run Operations: 141K pipeline runs; runs, duration and success rate, a weekday-by-hour heatmap, SLA breaches, orchestrators and execution engines.
Global Power Plants: 29,910 grid-scale plants in 164 countries; renewable share, generation by fuel, capacity by country, a per-country drill-down with capacity factor by fuel, build-out trend and commissioning decades.
Employee Sentiment: workforce, engagement, performance and risk metrics for 850K employees, each with a tenure or score-spread curve, job-level comparison and a persona ranking.
Sales Dashboard: Amazon product sales 2021 vs 2020; products, revenue, units and average price with sparklines, units over time, a year-over-year overlay, top products and a category donut.
CRM Sales Performance: pipeline KPIs month over month, deal mix by regional office, product and account sector, monthly win rate per office and a pipeline retention cohort grid.
1 / 16
02

Analytics Dashboards

Executive and operational dashboards that answer the question before it is asked.

Public portfolio on Tableau Public

The problem

Most dashboards are a grid of charts. A leader opens one, cannot tell what changed or why, and asks an analyst for the real answer. The dashboard has failed at its only job.

The product

Every one of these starts from the question the audience actually asks: how are we doing against last period, where is the change coming from, and what should I look at next. KPIs carry their comparison and sparkline; every chart filters the rest; color is reserved for meaning (good, warning, the selected period) and the layout is built for scanning, not reading. Five years of this work at Red Hat, serving Procurement, Corporate Expense and leadership, is where the discipline comes from.

  • KPI tiles with prior-period deltas, sparklines and plain-language notes
  • Cross-filtering: click any chart to filter the whole dashboard, with reset
  • Period, segment and category selectors; rank-by toggles; chart-type switches
  • Maps (state bubbles, country rounds, region hexmaps) alongside tables and bars
  • Cohort retention grids, win-rate lines per office and per-entity drill-down panels with capacity factors and fuel mix
  • Heatmaps for peak-time and run-time patterns; funnels and tenure rings for flow and mix
  • Export to PDF, PowerPoint and image; metric notes and data provenance in every footer
  • Light and dark visual systems matched to the audience and brand
Architecture & implementation
  • Tableau Desktop and Tableau Public; calculated fields, LOD expressions, parameters and set actions
  • Data prepared with SQL and dbt models; sample and synthetic datasets for the public portfolio
  • Design system per dashboard: type scale, semantic color, 8 px spacing grid, consistent tile anatomy
  • Dashboards sized for the viewing surface (tablet, laptop, wide) with device-specific layouts where needed
Evidence
  • Red Hat 2019–2024: dashboards and analytics for Global Procurement leadership and Corporate Expense teams
  • Public datasets: Sample Superstore, DataCo Supply Chain, CrunchBase export, WRI Global Power Plant Database v1.2.0, Amazon product listings, FAO AQUASTAT, IMF and World Bank, OSV.dev and GitHub advisories, METR, synthetic CRM, HR and pipeline telemetry
  • Tableau
  • SQL
  • dbt
  • Snowflake
  • Statistics
  • Data modeling
  • Data
  • Experience
Home: import a folder, a ZIP or a GitHub repository. Imported code is treated as untrusted data and never executed.
Code Review: 29 findings with IDs, severity, confidence, exact lines, evidence and a suggested patch.
Formal Proofs: the riskiest functions modelled in Lean 4, with counterexamples and a fidelity audit.
Code Map: functional areas, files and symbols as an interactive dependency graph.
Architecture view with change-impact panels, API and data-model maps.
System Explanation: four zoom levels, from the whole system down to a single symbol.
Executive reports exportable to PDF, Word, Markdown, HTML and PowerPoint.
Live AI cost tracking: tokens and dollars per analysis, in the header at all times.
The same analysis on a phone.
1 / 9
03

Brody

Repository intelligence for any codebase. Code is never executed.

Open source · CI passing · 493 tests MIT

The problem

Understanding and reviewing an unfamiliar codebase is slow, and AI review that cannot show its evidence does not earn trust. A finding without an exact line is a guess; a security claim without a proof is an opinion; an architecture summary nobody outside engineering can read never reaches the people who fund the fix. Teams need all three from one tool, and they need it to run without ever executing the code it is reading.

The product

Brody ingests a folder, ZIP or GitHub repository and treats every file as untrusted data. Tree-sitter parses it into a symbol and dependency graph; deterministic analyzers (ESLint, Ruff, gofmt) run first so the AI passes only see retrieved, relevant excerpts. Findings come back with IDs, severity, confidence, the exact lines, and a patch that is validated before it is suggested. The riskiest functions are modelled in Lean 4 and either proved safe or disproved with a concrete counterexample, with a fidelity audit of the model itself. The same analysis renders as an interactive Code Map, four zoom levels of explanation, an OWASP/CWE security review, a PII inventory, and an executive deck; token cost is on screen the whole time.

  • Findings with IDs, severity, confidence, exact lines and validated patches
  • Lean 4 proofs of real defects with concrete counterexamples and a fidelity audit
  • Interactive Code Map and Architecture views with change-impact panels
  • Security and privacy review: OWASP and CWE mapping, PII inventory
  • Executive reports and a 14-slide deck in PDF, Word, Markdown, HTML and PowerPoint
  • Ask-the-repository Q&A and portable Brody bundles
Architecture & implementation
  • Pipeline: Ingest → Parse → Symbol & dependency graph → Retrieve → Analyze → Prove → Verify → Explain → Map → Report
  • Tree-sitter parsing; deterministic analyzers (ESLint, Ruff, gofmt) before any AI pass
  • Lean 4 for formal verification of modelled functions
  • Next.js 16 + TypeScript, SQLite storage, Claude or OpenAI models
  • Imported code is treated as untrusted data and never executed
Evidence
  • 493 tests and a published validation report
  • No user authentication: intended for local or proxied use
  • TypeScript
  • Next.js
  • Tree-sitter
  • Lean 4
  • SQLite
  • Claude API
  • OpenAI API
  • AI
  • Software
  • Experience
Overview: connect a decision engine, create a workflow, run it, answer a human task, publish.
Expense approval: a $38.50 taxi claim within policy is approved without a manager.
IT help desk routing: a VPN outage affecting 30 people is triaged P1 and routed to the Network queue.
Every run is event-sourced and inspectable: replay, restart from a node, fork onto any version.
People in the loop: durable approvals, reviews and forms with SLAs.
Evaluation sets with regression checks against a baseline and a publish gate.
Calibration chart for a decision contract (ECE 0.013 on this set).
Ready-to-run business flows for finance, sales, IT and customer service.
1 / 8
04

FlowAId

Build, run and evaluate AI agents and workflows on your own computer, with typed decisions you can inspect, verify and trust.

Public beta · v0.9.0 · 6,256 tests Apache 2.0

The problem

Most agent frameworks let a generative model make every decision inside a prompt. That is expensive, hard to audit and impossible to calibrate, and it keeps the people who own the process (finance, sales, IT, support) out of the loop. When an expense is approved or a ticket is escalated, nobody can say how confident the system was or what evidence it used.

The product

FlowAId treats every decision as typed data: a yes/no, a choice or a score, returned with a calibrated probability under a versioned decision contract. Confidence and consequence decide what happens next: act automatically, gather more evidence, or route to a person. Runs are event-sourced, so any run can be replayed, forked onto a new version or restarted from a node; approvals, reviews and forms are durable, with an inbox and SLAs. Evaluation sets measure calibration and catch regressions before a workflow publishes. It ships with four ready-to-run business flows, a visual builder with 63 nodes, knowledge sources with hybrid search, and every workflow exposed as REST, MCP tools, a TypeScript SDK and signed webhooks. Local-first by design: your machine, your providers, your data.

  • Visual builder with an in-browser compiler, 63 core nodes plus 9 LangChain nodes, loops and subflows
  • Typed yes/no, choice and score decisions with versioned contracts and consequence-based thresholds
  • Event-sourced runs with live traces, replay, restart-from-node and fork
  • Durable human-in-the-loop: approvals, reviews, forms, an inbox with SLAs
  • Evaluation sets with calibration metrics, regression checks and a publish gate
  • REST, TypeScript SDK, CLI, workflows served as MCP tools, signed webhooks and schedules
Architecture & implementation
  • Turbo monorepo, TypeScript strict, Node.js 24, pnpm
  • apps/api: Fastify REST + SSE + MCP endpoint; apps/web: Next.js; apps/worker: orchestrator; apps/pageindex: Python document Q&A
  • PostgreSQL + pgvector with row-level security; hybrid search for knowledge sources
  • Envelope-encrypted credentials (local key, Vault, Azure Key Vault, GCP KMS); sandboxed code nodes
  • Prometheus and OpenTelemetry export; Docker Compose deployment; images on GHCR
  • Providers: OpenAI, Anthropic, Google Gemini, Ollama and any OpenAI-compatible endpoint
Evidence
  • 6,256 tests green in CI without PostgreSQL
  • Playwright end-to-end suite
  • Calibration ECE 0.013 on the shipped evaluation set
  • TypeScript
  • Fastify
  • Next.js
  • PostgreSQL
  • pgvector
  • Python
  • Docker
  • MCP
  • LangChain
  • Playwright
  • Vitest
  • AI
  • Software
  • Data
  • Infrastructure
Home: is it healthy, how fast is local AI, what is the DGX doing, what happened. Every tile drills down. (Demo data from the console test harness.)
Ask: private chat with local models. Every answer shows who answered, how fast, and that nothing left the box.
1 / 2
05

Labzilla

One machine. One cluster. A private AI platform on an NVIDIA DGX Spark.

Running in production on tiny-dgx

The problem

Private, local AI should be as easy to call as a cloud API, as reliable as a managed cluster, and cheaper than sending every step to a frontier model. Most home and lab setups are none of those: a GPU, a shell and a growing list of scripts nobody can reproduce.

The product

Labzilla is the full platform: a single-node k3s cluster on an NVIDIA DGX Spark, deployed from git by Argo CD so a push to main is a deploy, with Helm, Longhorn storage, MinIO backups on and off site, Prometheus and Grafana, MetalLB and Tailscale. One OpenAI-compatible gateway exposes logical models with fallbacks. The operating rule is "do not generate when you only need to decide": every agent step is routed to the cheapest executor that can do it correctly: plain code, then a calibrated decision, then a local model, then a frontier model, then a person. Decision engineering mines agent traces for the hidden decisions, turns them into versioned questions, and promotes them only after a person has seen the calibration. The console runs on a phone and shows, for every answer, who answered, how fast, and that nothing left the box.

  • OpenAI-compatible gateway with logical models (local/default, local/auto) and fallbacks
  • Decision engineering: mine agent traces for hidden decisions, lint, shadow, calibrate and promote them
  • Model lifecycle: Hugging Face discovery → benchmark → canary → promotion, with rollback
  • Knowledge layer: typed Markdown repos with a graph and an MCP server
  • Console as desktop and phone PWA with routing receipts and QR pairing
  • CLI: status, trust, open, doctor; pre-commit private-data guard
Architecture & implementation
  • Hardware: DGX Spark GB10, arm64, 128 GB unified memory
  • k3s single node; Argo CD app-of-apps; a push to main is a deploy; Helm charts
  • Longhorn storage, MinIO backups on- and off-site, Prometheus + Grafana, MetalLB, Tailscale, local CA for LAN HTTPS
  • Python 3.12 services; console in Preact + TypeScript; MCP servers for knowledge and decisions
Evidence
  • Decision benchmark (2026-10-01, 267 decisions): 94.4% correct, median 167 ms; at a 0.9 threshold 68% resolved automatically, all correct
  • Kubernetes (k3s)
  • Argo CD
  • Helm
  • Python
  • Preact
  • TypeScript
  • Prometheus
  • Grafana
  • MinIO
  • MCP
  • Infrastructure
  • AI
  • Data
The universe: every technology in the catalog as a physics-driven block on one canvas.
Charged launch: a request streams in and the chosen blocks assemble into an architecture row.
Every block explains the decision: why, tradeoffs, confidence, sources and a snippet.
The tech intelligence pipeline discovers and verifies technologies from nine sources.
1 / 4
06

Stack4That

Describe what you are building. Watch the stack assemble.

Live at stack4that.com MIT

The problem

Choosing a coherent set of technologies means weighing compatibility, tradeoffs and alternatives for every piece of the system, against knowledge that is scattered across docs and changelogs and goes stale within months. A list of logos is not an architecture.

The product

Stack4That turns one sentence into a validated architecture, and shows its work. It extracts intent and constraints, builds a requirement graph, retrieves candidates from a catalog of 750+ technologies, and lets a typed decision engine choose each one with a confidence score and sources. Compatibility is validated and the stack optimized before anything is shown. Results stream in over Server-Sent Events and land as physics-driven blocks in an architecture row with relationships drawn between them; each block explains the decision, its tradeoffs and an implementation snippet. "Use instead" swaps a technology and re-evaluates its dependents in the same thread. A nine-source intelligence pipeline keeps the catalog current.

  • A browsable universe of technology blocks simulated on one canvas
  • Streaming assembly with relationships drawn between chosen blocks
  • Per-block explanation: decision, tradeoffs, confidence, sources and an implementation snippet
  • Iteration in the same thread: swap a technology, rebuild the stack
  • Tech intelligence pipeline that discovers and verifies technologies from nine sources
  • CLI for the local server, pipeline and setup
Architecture & implementation
  • Next.js + TypeScript; Matter.js physics on a single canvas
  • Pipeline: intent extraction → requirement graph → hybrid retrieval → decision engine → compatibility validation → stack optimizer → streaming assembly
  • libSQL with local SQLite default (Turso optional); embeddings via hash, OpenAI-compatible endpoint or local BGE
  • Vitest, ESLint and axe-core accessibility checks in CI
  • TypeScript
  • Next.js
  • Matter.js
  • libSQL
  • SSE
  • Vitest
  • axe-core
  • AI
  • Experience
  • Software
Studio: choose the camera. Grok Imagine or Google Flow, keys stay on your machine.
Director: one line in, a scripted, priced shot list out. Nothing rolls until you see the price.
1 / 2
07

Diony AI

One line in. A priced, finished film out.

Desktop app · v0.22.0 · macOS and Windows Proprietary

The problem

AI video tools produce clips, not films, and bill you after the fact. Producing something coherent means juggling a script, continuity between shots, per-second pricing, voices and an edit across several services, with no idea what it will cost until it is done.

The product

Diony AI is a desktop film studio that shoots on cloud video models. The Director writes the script and a master video prompt, locks the cast with face approval, prices every shot from versioned rate cards and shows the total before anything rolls. Clips render on Grok Imagine or Google Flow with retake, skip and retry per shot; a rate limit pauses the run instead of failing it. The film is reviewed, cut, narrated and subtitled, then delivered with an EDL, assembly map, QC packet and a receipt comparing estimate to actual. Guards cover likeness, continuity and speech. API keys and every asset stay on the user's machine, in signed installers for macOS and Windows.

  • Three surfaces: Studio, Director and Producer
  • Script lock with an itemised price; cast lock with face approval
  • Retake, skip and retry per shot; a rate limit pauses the run instead of failing it
  • Deliverables: film, subtitles, EDL, assembly map, QC packet and receipt
  • Guards for likeness, continuity and speech; prompts fitted to model limits
  • Versioned JSON rate cards with stale-card warnings
Architecture & implementation
  • Python 3.11+, FastAPI and uvicorn, Pydantic v2; static HTML/JS consoles with no SPA framework
  • Bundled ffmpeg pinned and SHA-256 verified; SQLite ledger
  • Desktop builds via PyInstaller: signed Universal 2 on macOS, Inno Setup installer on Windows
  • Engines: xAI Grok Imagine and voice, Google Flow via useapi.net, Gemini for TTS, optional faster-whisper
Evidence
  • 879 tests in the offline suite (product audit, 2026-10-13)
  • Python
  • FastAPI
  • PyInstaller
  • ffmpeg
  • SQLite
  • xAI API
  • Google Flow
  • Gemini
  • AI
  • Software
  • Experience
ZComb Kanban: builder, critic and human approval tracked as cards, with budgets and loop controls.
1 / 1
08

AbsoLoop

Evidence wins. Budgets bind. The critic does not take your word.

Open source · CI MIT

The problem

Autonomous coding agents claim "done" with no evidence, run without budgets, and leave a person to discover what actually changed. Running several of them makes it worse: more claims, more cost, less certainty.

The product

AbsoLoop makes agent work accountable. A mission starts from a goal contract that classifies the objective and defines done. The builder (Claude Code, Codex or Grok Build, in single, review, race or council strategies) must show evidence; a read-only adversarial critic tries to disprove it; and a person approves, rejects, extends or aborts. Iterations, wall clock and dollars are hard limits. Everything runs in isolated git worktrees with deterministic gates, delivers as local changes, a branch or an output folder, and is visible on the ZComb Kanban board or in the terminal. The core is Python with zero pip dependencies, and the scheduler never auto-approves.

  • Goal contracts with a strategy ladder and thinking-escalation ladder
  • Strategies: single, review, race and council across Claude Code, Codex and Grok Build
  • Hard budgets for iterations, time and cost; approve, reject, resume, extend, abort
  • Delivery as local changes, a git branch or an output folder
  • ZComb Kanban UI, terminal watch mode and Markdown reports
  • Scheduling that never auto-approves
Architecture & implementation
  • Python 3.9+, stdlib-only core with zero pip dependencies
  • Two-layer teams: AbsoLoop orchestrates; each builder fans out with its native subagents
  • Isolated git worktrees with deterministic gates; runner exit codes for completed, awaiting approval, stopped
  • Static site deployed behind Caddy on a Hetzner host
  • Python
  • Claude Code
  • Codex
  • Git worktrees
  • Node.js
  • AI
  • Software
Home: the Agentsphere landing page with the four entry cards (Explorer, Builder, Operator, Power user), each stating who should start there and what they will be able to do.
Four levels, one path: the level table on the home page; stop at the end of any level and you still have a skill.
Explorer path: the 15-minute first run for someone who has only used a chatbot; chatbot vs agent, path, time and prerequisites up front.
The agent loop: the six steps (perceive, plan, act, observe, remember, stop) as a table with a research example per step, and the loop drawn as a flowchart.
Harness engineering: the model proposes the next step, the harness decides; observation, context, control, action, state and verification around the model.
Tools and MCP: host, model API and MCP client, with servers for files, a browser or shell, and another agent; claims labelled Established, Per post or Synthesis.
Orchestration: lead, phases, merge; one agent writes the plan, workers take slices, one reviewed result comes back.
Threat model: what an agent can reach, where injection and untrusted skills get in, and the narrow-tools, redaction and review controls, plus a one-page model to fill in.
Evals: did it get better? Outcome, trajectory and cost as the three numbers to report, with a rubric and a regression set.
Hosted agents: products you can rent, read from the providers' official pages with the date opened and the questions to ask a vendor.
Wiki memory: the loop where an agent searches its own wiki first, reads raw sources only on a gap, and writes the answer back so the next run starts smarter.
1 / 11
09

Agentsphere

A field guide to AI agents, from first try to fixing a stuck one.

Open source · v0.4.6 MIT

The problem

Agent knowledge is scattered across vendor docs, papers and threads, moves monthly, and mixes settled practice with speculation. Newcomers cannot tell where to start; operators cannot tell what to trust; and nobody has a map of the whole landscape.

The product

Agentsphere organizes the field around one idea: the harness, the system around the model that controls what it sees, what it can do, what it remembers and when it stops. Four learning paths (Explorer, Builder, Operator, Power user) walk through eleven sections: foundations, patterns, tools and MCP, prompting and skills, multi-agent systems, runtime and memory, evals, security, case studies, playbooks and a hosted-agent comparison. Every claim is tagged Established, Per post or Synthesis with its source, and a glossary, reading guide and references anchor the terms. Built with MkDocs and shipped through GitHub Actions, it is versioned like software and updated like one.

  • Four role-based learning paths with time estimates, from a 15-minute Explorer start to fixing a stuck agent
  • Eleven sections with original diagrams for the harness, memory types, orchestration, security loops and the agent landscape
  • Playbooks: stop a looping agent, write a reusable skill, score a run
  • Hosted-agent comparison across four providers, built from official docs with the date opened
  • Claim labelling (Established · Per post · Synthesis) so readers know how far to trust each statement
  • Glossary, reading guide, community list and references
Architecture & implementation
  • MkDocs with custom hooks and theme overrides; content as Markdown with a typed section map
  • Original SVG diagram set in light and dark variants; section cards generated for navigation and social previews
  • GitHub Actions builds and deploys to GitHub Pages on every push; semantic versioning with a changelog (v0.4.6)
  • MkDocs
  • Python
  • Markdown
  • SVG
  • GitHub Actions
  • GitHub Pages
  • AI
  • Experience

The professional behind the work

From the balance sheet to the inference server.

Portrait of Rohn Springfield
Rohn Springfield AI engineer and data scientist · Raleigh, North Carolina

I started in finance: pricing models, rate cards and SAP configuration for utilities. It taught me to respect the number on the page and the person who has to act on it. At Red Hat I spent five years turning organizational data into analytics that leaders actually used: dbt transformations, Tableau dashboards, and the statistical work behind procurement and expense decisions.

In 2025 I moved from analyzing systems to building them. Since then I have designed and shipped eight AI products on my own: an autonomous news platform on web, iOS and Android; a repository intelligence tool that proves its findings in Lean 4; a workflow platform where every decision carries a calibrated probability; a private inference cluster I run on my own hardware; a desktop film studio; and the orchestration layer that keeps agents honest with budgets, evidence and a human gate. Each one is built so that someone who is not an engineer can see what the system decided, why, and what it cost.

The through-line is ownership. I take a problem from the first question to a running, tested, documented product, and I stay responsible for it in production: deploys, observability, cost and rollback. I publish the numbers, including the ones that are not flattering, because a result nobody can check is not a result.

Education
Bachelor's degree, Finance, North Carolina State University (2010 – 2015)
  1. Nov 2025 – Present

    Founder, AI & Data Solutions Builder

    BLERBZ · Raleigh, NC

    • Built and deployed production web, iOS and Android apps for an AI news intelligence platform, owning architecture, implementation, testing and release.
    • Engineered autonomous operations across data ingestion, story ranking, AI enrichment and media production.
    AI engineering
  2. Jan 2025 – Present

    Independent AI & Software Engineering

    Open source, freelance · Raleigh, NC

    • Designed and delivered AI applications for business automation, software development, media production and private inference: AbsoLoop, FlowAId, Labzilla, Brody, Diony AI, Stack4That and Agentsphere.
    AI engineering
  3. Jul 2022 – Dec 2024

    Senior Data Scientist

    Red Hat · Raleigh, NC

    • Applied Python, SQL, machine learning and statistical analysis to complex organizational data to support decisions and performance analysis.
    • Partnered with Global Procurement leadership and Corporate Expense teams on reporting and analytics built on dbt transformations and Tableau dashboards.
    Data science
  4. May 2019 – Jul 2022

    Data Visualization Analyst

    Red Hat · Raleigh, NC

    • Built dashboards and visual analytics that made organizational data accessible to business stakeholders.
    • Developed repeatable analytical workflows that turned complex findings into clear business narratives.
    Analytics
  5. Aug 2016 – Apr 2019

    SAP FI Functional Consultant

    UTL Systems Inc. · Raleigh, NC

    • Connected financial requirements with SAP FI configuration on transformation projects for GRU, Alagasco and Puget Sound Energy.
    Enterprise systems
  6. Feb 2015 – Aug 2016

    Pricing / Financial Analyst

    HCL Technologies · Raleigh, NC

    • Developed pricing models, rate cards and financial templates for the Application Services bid management group.
    Finance
  7. Aug 2014 – Feb 2015

    Financial Analyst

    Worldwide Clinical Trials · Morrisville, NC

    • Financial analysis and contract change-order coordination.
    Finance

What I do

Five disciplines, one practice.

Data work earns its keep when it becomes a decision. Decisions earn trust when they ship inside reliable software. Software earns adoption when the experience is obvious. Each discipline below links to the products that prove it.

01

Data Science & Analytics

Statistical analysis, machine learning, data engineering, business intelligence and decision support.

  • Five years at Red Hat turning organizational data into dbt models, Tableau dashboards and decisions for Procurement and Expense teams
  • Calibration metrics and regression gates in FlowAId; a dated, sampled decision benchmark in Labzilla
  • A finance foundation: pricing models, rate cards and SAP FI before data science
02

AI & Intelligent Systems

LLM applications, agents, retrieval, orchestration, model evaluation and intelligent automation.

  • Typed, calibrated decisions instead of free-text model output (FlowAId, Labzilla, Stack4That)
  • Formal verification of AI findings in Lean 4 (Brody)
  • Bounded, evidence-gated agent loops with budgets and an adversarial critic (AbsoLoop)
03

Software & Product Engineering

Full-stack development, APIs, architecture, integrations, testing, reliability and production delivery.

  • TypeScript monorepos with REST, SSE and MCP APIs, SDKs and CLIs (FlowAId)
  • Signed desktop installers for macOS and Windows (Diony AI)
  • Thousands of automated tests in CI across products
04

Experience & Product Design

Human-centered UX, responsive interfaces, accessibility, information architecture and intuitive interaction.

  • A physics-driven canvas that makes architecture decisions legible (Stack4That)
  • Phone-first console with routing receipts and QR pairing (Labzilla)
  • axe-core accessibility checks in CI; four zoom levels of explanation for different readers (Brody)
05

Infrastructure & Operations

Cloud hosting, containers, deployment, observability, optimization, security and maintainability.

  • Single-node Kubernetes with GitOps, Helm, Longhorn, MinIO backups and Prometheus/Grafana on a DGX Spark (Labzilla)
  • Docker Compose deployment and GHCR images; envelope-encrypted credentials (FlowAId)
  • Static sites served by Caddy on an independently managed host (absoloop.ai, diony.ai)

How I build

Understand, architect, build, validate, ship, improve.

Not a rigid methodology; a set of habits that show up in every product. The order flexes; the standards do not.

  1. Understand

    Start from the real problem and the people who have it. Write down what "done" means before writing code.

    • Stakeholder questions turned into structured analyses
    • Explicit goal contracts and definitions of done
    • Evidence over assumption

  2. Architect

    Choose the smallest system that can be trusted. Decide where a model belongs and where plain code is cheaper and safer.

    • Typed decisions and contracts
    • Code → calibrated decision → model → human escalation
    • Data model first

  3. Build

    Ship complete products: APIs, interfaces, installers and docs, not prototypes.

    • TypeScript strict and Python 3.11+
    • Component-driven UI
    • Local-first by default

  4. Validate

    Prove it. Unit, integration and end-to-end suites, calibration metrics, and formal proofs where the stakes justify them.

    • CI on every push
    • Calibration and regression gates
    • Lean 4 proofs for critical findings

  5. Ship

    Own the path to production: containers, GitOps, signed desktop builds, observability and rollback.

    • Docker Compose and k3s with Argo CD
    • Prometheus and OpenTelemetry
    • Signed macOS and Windows installers

  6. Improve

    Measure what happened, publish the numbers, and feed them back into the next decision.

    • Cost and latency receipts in the UI
    • Benchmarks with dates and sample sizes
    • Changelogs that say what changed
  • Evidence-based decisions. Benchmarks carry dates and sample sizes; findings carry line numbers.
  • Responsible AI. A model gets the decisions it is good at. Code, calibrated decisions and people get the rest.
  • Production ownership. If I built it, I run it: deploys, observability, rollback, cost.
  • Human-centered. The approval inbox, the price before the run, the routing receipt; the interface is the product.

Technology & engineering depth

Organized by what it does, not by logo.

Pick a product to see what it is built from. Every item names where it was used.

Showing all 43 technologies

  • Production · shipped products or enterprise work
  • Hands-on · used in a public project
  • Exploratory · evaluated

Languages

  • Python Red Hat · Labzilla · Diony AI · AbsoLoop · Agentsphere · BLERBZ
  • SQL Red Hat · Analytics Dashboards · Enterprise roles
  • TypeScript Brody · FlowAId · Stack4That · BLERBZ

Data & analytics

  • dbt Red Hat · Analytics Dashboards
  • Tableau Red Hat · Analytics Dashboards
  • Snowflake Red Hat · Enterprise roles
  • AWS S3 / Redshift Red Hat
  • Machine learning & statistics Red Hat
  • Financial modeling Enterprise roles
  • PostgreSQL + pgvector FlowAId
  • SQLite / libSQL Brody · Stack4That · Diony AI
  • Redis Enterprise roles · Labzilla

AI & agents

  • LLM APIs (Claude, OpenAI, Gemini, xAI) Brody · FlowAId · Diony AI · Stack4That · BLERBZ · Agentsphere
  • Agent orchestration BLERBZ · AbsoLoop · FlowAId
  • Text-to-speech & media generation BLERBZ · Diony AI
  • RAG & hybrid retrieval FlowAId · Stack4That · Brody · Red Hat
  • MCP FlowAId · Labzilla · BLERBZ
  • Calibrated typed decisions (TypeSafe / Jev) FlowAId · Labzilla · Stack4That
  • LangChain FlowAId
  • Local models & Ollama Labzilla · FlowAId · Red Hat
  • Lean 4 formal verification Brody
  • Tree-sitter Brody
  • Claude Code · Codex · Cursor AbsoLoop · Agentsphere

Application engineering

  • React / Next.js Brody · Stack4That · FlowAId
  • Preact Labzilla
  • Fastify FlowAId
  • FastAPI Diony AI · BLERBZ
  • Server-Sent Events Stack4That · FlowAId
  • Matter.js Stack4That
  • PyInstaller desktop packaging Diony AI
  • Native iOS & Android apps BLERBZ
  • Vitest · Playwright · axe-core FlowAId · Stack4That · Brody

Infrastructure & operations

  • Docker & Compose FlowAId · Diony AI
  • Kubernetes Labzilla
  • Argo CD GitOps Labzilla
  • Prometheus · Grafana · OpenTelemetry Labzilla · FlowAId
  • Caddy AbsoLoop · Diony AI · Labzilla
  • AWS Red Hat · AbsoLoop · BLERBZ
  • Longhorn · MinIO · Tailscale Labzilla

Enterprise systems

  • SAP FI Enterprise roles
  • Oracle EBS Enterprise roles · Red Hat
  • Jira Red Hat · Enterprise roles
  • MkDocs · GitHub Pages Agentsphere · Brody · FlowAId · Labzilla

Professional principles

Six commitments, each with a receipt.

  1. Craft

    Details matter, from the shape of an API to the weight of a heading.

    Brody ships a 14-slide executive deck, five export formats and a phone layout for the same analysis, because a finding nobody can read is not a finding.

  2. Accountability

    Own the outcome, not the ticket.

    AbsoLoop makes autonomous development accountable: a loop only closes when the builder shows evidence, an independent critic finds no blocking issue, and a person approves.

  3. Integrity

    Represent what the system can and cannot do.

    Labzilla publishes its decision benchmark with the date and sample size, and labels console screenshots as demo data. Brody prints token cost in the header at all times.

  4. Usability

    Sophisticated systems should feel obvious to the people using them.

    Stack4That turns a sentence into an architecture you can watch assemble; FlowAId gives non-engineers an inbox, approvals and forms instead of a config file.

  5. Reliability

    A demo working is not the same as a product working.

    FlowAId runs 6,256 tests in CI plus Playwright end-to-end suites; Diony verifies its bundled ffmpeg by SHA-256 and pauses a run on rate limits instead of failing it.

  6. Curiosity

    Keep asking what the evidence actually supports.

    Agentsphere labels every claim as Established, Per post, or Synthesis; Brody proves real defects in Lean 4 rather than describing them.

Contact

Have a complex problem worth solving?

Roles, collaborations, product builds and technical conversations are all welcome. One email is enough; I reply to every serious message.

rspringfield91@gmail.com