Projects

Selected things I have built, shipped, or keep pushing forward. Less portfolio theatre, more proof-of-work, systems thinking, and applied architecture.

Personal agent toolchain

The current public repo stack behind Jason: the operating layer for planning, waiting, reviewing, remembering, measuring, and documenting agent work.

New public stack

From chat helper to operating system

This is the newer agent work: a set of repos that make the assistant more dependable when work crosses repos, waits on CI, needs a critic, or has to prove that something is really shipped.

Read the toolchain article Orchestration hub

What it is for

  • Make ambiguous work concrete before touching code.
  • Keep long-running tasks alive without stale chat context.
  • Catch overclaims before they become public updates.
  • Promote useful memory and leave noisy notes behind.
  • Measure whether the agent is actually improving.

Agent Workbench

Run setup

Turns a messy request into objective, lanes, briefs, state, artifacts, gates, and final-report scaffolding.

GitHub

Agent QA / Red Team

Review

Adds a read-only second pass for bugs, weak claims, privacy issues, missing validation, and release risk.

GitHub

Agent Memory Distiller

Memory

Separates raw daily notes from compact long-term memory so the assistant remembers signal, not clutter.

GitHub

Memory Cluster Index

Recall

Clusters memory by topic and keeps a local chunked search index so old context is faster and cheaper to retrieve.

GitHub

TaskFlow Agent Runner

Durable work

Defines the wait, resume, approval pause, child-task, artifact, finish, fail, and handoff pattern.

GitHub

Agent Evaluation Harness

Measurement

Scores agent runs against fixtures and rubrics for honesty, validation, safety, usefulness, and regression.

GitHub

Code Doc Pipeline

Docs rail

Generates repo docs and Mermaid diagrams, then uses CI drift checks to keep documentation honest.

GitHub

Skill Publisher Pipeline

Release rail

Packages skills and proposals into release-ready repos, artifacts, validation reports, and publishing checklists.

GitHub

Featured projects

The stronger examples of how I think, build, and structure real systems.

1

Personal Agent Toolchain

A growing public toolchain for running a personal AI assistant like an operating system instead of a clever chat window.

Role: Agent workflow design, evaluation design, public skill packaging, CI documentation rollout, and personal automation hardening.
Constraint: Had to be useful in a private local assistant setup while still being generalized, sanitized, documented, and public enough for reuse.

Problem: Most agent examples stop at the impressive demo. Real personal agents also need scoped work packets, QA, memory boundaries, durable waits, evaluation, repo maintenance, and docs that stay honest in CI.

Why it matters: It turns repeated assistant failure modes into reusable operating procedures: workbench runs, red-team review, memory distillation, TaskFlow handoff, behavior evaluation, and repo documentation checks.

Read the new write-up Read the write-up Agent Workbench QA / Red Team Evaluation Harness Code Doc Pipeline Memory Cluster Index
2

Household Chores

Home Assistant

A Home Assistant task system built for actual household coordination, not just another database with a nicer skin.

Role: Product design, integration design, Home Assistant implementation, and assistant workflow orchestration.
Constraint: Had to work across household context, chat interaction, automation logic, and a UI that people would actually use without resenting it.

Problem: Most task systems break in the real world because adding, assigning, and completing chores still takes too much effort. They store tasks fine. They are bad interfaces.

Why it matters: This project connects product thinking, Home Assistant, automation, and chat-based interaction into one practical system. It is a better example of full-stack systems design than a simple dashboard or toy app.

Read the write-up GitHub
3

Home Brief

Home Assistant

A Home Assistant integration for generating and rendering a persistent daily brief across assistant and dashboard surfaces.

Role: Integration architecture, UI surface design, assistant publishing contract, and Home Assistant implementation.
Constraint: Needed a cleaner separation between generation and rendering so the brief could persist and stay stable across surfaces instead of being recomputed ad hoc.

Problem: AI-generated summaries are usually ephemeral. They show up once in chat, then disappear. This project turns them into stable, reusable household information.

Why it matters: It bridges assistant output, structured payloads, and in-home presentation instead of treating AI as a one-shot message generator.

Read the write-up GitHub
4

Home Assistant HACS Template

Home Assistant

A reusable foundation for building Home Assistant integrations faster without rewriting the same scaffolding every time.

Role: Tooling and integration scaffolding for faster future delivery.
Constraint: Needed to be generic enough to reuse, but opinionated enough to speed up real implementation instead of becoming another empty starter kit.

Problem: Starting a custom integration from scratch often means redoing the same setup work before any actual product value gets built.

Why it matters: This is the kind of tooling work that compounds. It makes future integrations cleaner, faster to ship, and easier to maintain.

Read the write-up GitHub

Working With Jason

A practical AI collaboration model shaped around systems thinking, writing, product direction, execution, and actual delivery instead of chatbot theatre.

How Jason thinks

  • Useful beats impressive.
  • Systems beat one-off hacks.
  • Clarity beats fluff.
  • Shipping beats endless planning.
  • Good taste matters.
  • AI is only valuable when it survives real workflows.

What Jason can do

  • Shape product ideas into sharper, more buildable directions.
  • Write and edit with a more human, less synthetic cadence.
  • Build and ship changes across code, content, and automation systems.
  • Structure workflows, task routing, and operational glue.
  • Connect systems and reduce the chaos that grows between teams, tools, and abstractions.

What we have built together

  • Household Chores
  • Home Brief
  • Personal Agent Toolchain
  • Skill Publisher Pipeline
  • Code Doc Pipeline rollout
  • This website and its positioning/content system
  • Workflow and memory systems
  • Automation and integration experiments

Where it is less useful

  • Not a replacement for deep domain ownership.
  • Not magic when the underlying system is messy and nobody wants to decide.
  • Not a substitute for real taste if nobody curates the output.
  • Less useful when goals stay vague on purpose.

The useful version of this is not “talk to a chatbot.” It is having a system that can think across writing, product direction, architecture, workflows, and execution without losing the thread every five minutes. The point is leverage, not novelty.

Experiments

Smaller bets, evolving systems, and things that are still becoming clearer.

Family Ops

Concept

A mobile-first family logistics and smart scheduling concept built around modular building blocks instead of a tightly coupled mess.

Agentic workflow experiments

AI Systems

Ongoing work around AI-assisted workflows, orchestration, memory, task routing, and the gap between impressive demos and dependable systems.

Publishing and content systems

Publishing

The site itself is also an evolving experiment in structured publishing, better content packaging, and building a cleaner system around writing.