Understand the need
Learn the decision, workflow, limits, and real consequence of failure before choosing the technology.
Forward-Deployed AI Solutions
AI systems built to solve real problems—and prove they work.
I start with the work that needs to improve, decide where AI can genuinely help, and build the tools, memory, safeguards, and testing around it. A result moves forward because the evidence supports it, not because the model produced a convincing answer.
What I bring to an AI team
I connect the model to the work around it.
I turn an unclear need into a system people can understand, test, operate, and improve across models and frameworks.
Design the whole system
Connect the model with the right context, data, tools, permissions, monitoring, and recovery.
Review and correct implementation
Read and trace code, evaluate state, resource, and network behavior, and redirect approaches that conflict with the system’s requirements.
Prove the result
Move from code and tests to the real application, installation, network, hardware, or operating environment.
Core AI systems and research
The platforms and research at the center of the lab.
Each project explains the operating problem, what I owned, the present maturity, and the evidence used to decide what moves forward.
Research-characterized prototype · current project
Local decision intelligence · structured model evaluation
STRATA — Local Decision Intelligence
Directed a local research program testing whether a compact open model can make clear, bounded decisions over shared evidence more reliably and efficiently than free-form generation. Controlled comparisons, state-reuse trials, probability analysis, adversarial evidence variants, and review workflows turn both positive and negative results into next decisions.
Latest evidence: a 1,000-question evaluation rejected model promotion when executable rules performed better; a qualified serial-reuse fixture showed a bounded 43.81% latency reduction; a shortcut audit stopped an invalid model evaluation; and 85 of 85 maintained CPU checks pass.
Installed + exercised
Local AI framework · semi-agents · modules
Pegasus Cerebral
A work framework for local models that adds bounded agent roles, durable jobs, operator decisions, tools, recovery, and domain modules. Cerebral integrates Cortex for continuity and governed local operations; Pegasus Books is the current extension example.
Demonstrates: AI platform design, small-model orchestration, technical product direction, responsible expandability.Installed + integrated
Continuity · retrieval · typed operations
Pegasus Cortex
A durable continuity and governed-operations layer that gives AI work stable identity, bounded context retrieval, recoverable task state, and explicit local capabilities.
Demonstrates: context engineering, knowledge boundaries, authority design, lifecycle recovery.Active controlled research
Geometric / latent reasoning
Model-efficiency research
Translated paper-derived ideas into controlled local experiments, then held the approach when shorter output did not preserve answer quality.
Demonstrates: experiment design, model evaluation, failure analysis, promotion decisions.Additional products and experiments
Applied AI work across coordination, privacy, visualization, and product development.
These systems extend the same method into distinct operating problems while retaining their own maturity and evidence boundaries.
Playable prototype
Human-in-the-loop product development
Neural Commander
Used hands-on playtesting to turn a broad game idea into deterministic system behavior, explicit contracts, content controls, and repeatable runtime evidence.
Demonstrates: product direction, UAT, complex-state modeling, AI-assisted delivery.Two-computer verified
Cross-computer AI coordination
Pegasus Agent Mail
Separated bounded task context from lightweight wake notifications so agents on two computers could exchange work without a relay reading message bodies.
Demonstrates: distributed workflows, privacy, identity, delivery semantics.Active development
Local-first agent relay
Pegasus Exchange
Turned writer locks, false wake states, delivery loops, and unbounded history into explicit lifecycle states, bounded APIs, durable correlation, and repeatable regression checks.
Demonstrates: failure analysis, concurrency, delivery architecture, truthful status.Private alpha
Privacy + explainability
Personality Synthesis Engine
A deterministic self-reflection product that keeps profiles client-held and AI out of scoring, confidence, routing, and compatibility decisions.
Demonstrates: privacy-first product design, explainability, governed content.Active development
Offline developer tools
CodeConstellation
Turns code structure and relationships into an explorable 3D map so a developer can understand a complex or AI-assisted codebase without sending source to a cloud service.
Demonstrates: developer experience, product direction, visualization, UAT.How I direct AI work
AI helps build. Evidence decides what gets accepted.
I use AI to expand what can be explored and implemented, but people remain responsible for the requirements, tradeoffs, corrections, and final decision.
That work rests on hands-on programming and systems experience. I continue deepening my understanding of AI construction and model-context behavior so architecture decisions remain grounded as the field changes.
- 01
Understand the real problem
Start with the workflow and the result the user actually needs.
- 02
Define the rules
Decide what information is used, what actions are allowed, how failure should look, and what counts as success.
- 03
Divide the work clearly
Give specialist agents focused responsibilities, shared expectations, and human review.
- 04
Test the real system
Move beyond code review into the application, installation, hardware, network, or live environment.
- 05
Keep uncertainty visible
Record what failed, what remains unknown, and what still needs proof.
AI capabilities + technology
The skills behind the case studies.
These capabilities are demonstrated in context through the case studies above.
AI products
- Use-case discovery
- Human-in-the-loop design
- Requirements + acceptance
- Privacy + explainability
- Long-form workflows
Agent platforms
- Identity + authority
- Durable jobs
- Tool contracts
- Context continuity
- Interruption recovery
Local AI operations
- Model residency
- Resource fitting
- Inference runtimes
- Windows services
- Packaging + repair
Evaluation
- Matched controls
- Fresh evaluation sets
- Regression testing
- Native runtime evidence
- Failure analysis
Engineering stack
- C# + .NET
- PowerShell + Python
- TypeScript + JavaScript
- SQLite
- MCP + structured tools