I build AI-assisted systems in two connected directions:

1. Agentic AI security tooling - benchmarks, handoff checks, and safety workflows for agents that read files, tools, memory, model output, and other agents.
2. AI-assisted trading systems - a trading research and paper-observation stack where LLM output is treated as a proposal, then challenged by validators, backtests, evidence gates, and owner review.

The common rule is simple:

AI output is not truth until it survives validation.

The working loop is:

question -> bounded system -> tests -> traces -> reports -> review -> next iteration

I use coding agents as engineering leverage. The useful artifact is not the chat that produced the code; it is the code, tests, schemas, reports, and failure evidence that other people can inspect.

My main public security project is Agentic Security Harness: a defensive benchmark for testing whether AI coding agents treat untrusted repo text as data instead of authority. The included local demo compares a vulnerable synthetic agent against a protected version across 24 boundary-failure patterns and records traces, scorecards, and remediation output.

The trading stack is a separate applied direction, not a security side project: trading-bot-v2 and honest-backtest implement a public research and paper-validation discipline. Live execution is outside the supported portfolio and would require a separate architecture and owner decision.

The documentation hierarchy and public/private boundaries are defined in the Documentation Contract. That contract is the portfolio-level source of truth for which documents are current, which are repo-local, and which are archive/history.

The security line now has a generated public Security Portfolio Roadmap with explicit module owners, dependencies, evidence ceilings, phase exit criteria, residual risks, and owner gates. Its private canonical source remains in Runtime Guard; the projection grants no operational authority.

Agentic Security Harness is the main public security project.

It is a defensive benchmark toolkit for measuring agentic AI failure modes with:

• deterministic local targets;
• portable traces and scorecards;
• scenario matrices and run diffs;
• OpenAI-compatible external model/runtime checks;
• remediation guidance;
• schema validation and local report generation.

It is not a hacking toolkit and not a promise of complete protection. It is a measurement and learning lab for authorized, synthetic, local, or explicitly owned targets.

The trading line is an applied AI-assisted trading system, not a signal service and not a public profitability claim.

Public repositories show the method:

• trading-bot-v2 - local research workbench with scanner, market-data preparation, strategy lab, and paper-only validation boundaries on the path toward automation.
• honest-backtest - layered trading judge that challenges AI-generated setup ideas with costs, splits, robustness, overfit checks, forward logs, and adversarial review before they become decisions.

Private repositories hold real candidate rankings, parameter libraries, operational state, and market-specific findings. The public claim is process quality, not trading profitability.

Not everyone needs to run a full benchmark. A lighter repo now holds short LLM safety skills and playbooks that make boundaries explicit during everyday work:

• repo text, logs, and tool output are data, not instructions;
• secrets and credentials stay out of model context;
• model-generated URLs, package names, API endpoints, and webhooks require verification before use;
• AI agents should work through issue, branch, PR, and review gates;
• handoff notes need source, scope, confidence, and checked/not-checked fields;
• security research stays on synthetic, mock, owned, or explicitly authorized targets.

These playbooks will reduce ambiguity. They will not replace runtime controls, tests, validators, or the benchmark itself.

AI agents increasingly pass files, memory, tool output, approvals, and context between runtimes. That handoff is often treated as plain text, but it carries trust, provenance, and authority.

Current and planned work:

• ai-agent-handoff - a file-based handoff protocol for AI coding agents plus a small guard hook.
• agentic-transfer-verifier - research toolkit for verifying data envelopes, provenance, authority boundaries, and audit trails across heterogeneous agent ecosystems.

1. Find a real operational weakness.
2. Turn it into a bounded research question.
3. Build a deterministic harness or workflow around it.
4. Use agents for implementation and review under explicit constraints.
5. Verify with tests, schemas, reports, and adversarial review.
6. Publish reusable methods while keeping private data and credentials private.

Public:

• methods;
• test harnesses;
• synthetic examples;
• docs;
• schemas;
• sanitized reports;
• reproducible CLI flows.

Private:

• trading results and candidate rankings;
• live parameters;
• provider credentials;
• private logs;
• operational dashboards;
• raw market research state.

• Current portfolio state
• Security Portfolio
• Trading Portfolio
• Repository catalog and roles

These four pages lead to current state, architecture, roadmap, evidence, the next gate, and authority boundaries in no more than two transitions. Governance and document precedence are defined in the Portfolio Governance and Documentation Contract.

• Security product roadmap: agentic-runtime-guard
• Security benchmark/evidence: agentic-security-harness
• Transfer verification: agentic-transfer-verifier
• Agent handoff protocol: ai-agent-handoff
• Safety guidance: llm-safety-playbooks
• Trading research and paper system: trading-bot-v2
• Skeptical Trading validator: honest-backtest
• LLM routing: llm-router
• LLM triage: llm-cheap-filter

• Agentic AI Security Platform
• Trading Research Platform
• LLM Infrastructure

GitHub is the best starting point. I am interested in practical AI security, agentic workflow safety, AI-assisted trading systems with validation discipline, LLM infrastructure, and research systems where measurement matters more than hype.