Automated Cyber
Solutions

Projects

Engineering work, open to inspection.

Recent local engineering and earlier open-source work, with contributions, evidence, and limitations made explicit.

Implementations & experiments

Selected projects

Browse seven case studies, newest first. Each separates my contribution, the implementation, evidence, and remaining limitations.

Open-source integration · 2019–2020

CyberRange

An automated AWS security lab with documented infrastructure, tools, environment checks, and public presentations.

Read the case study →

7 selected case studies

More AI engineering · 2026–2025

From agent activity to usable information.

I build workflows around a defined question, explicit inputs, tool access, review points, and a concrete deliverable. These projects explore different parts of that process; the implementation stage and limits are described for each.

AI Optimizer · model gateway & governance

A local gateway implementation for model requests, streaming pass-through, telemetry, and deterministic routing with reason codes. Configuration supports observation, shadow recommendations, enforcement, budget checks, and bounded escalation.

My work connects API integration to operational visibility and reviewable decisions. Unit and integration checks cover routing and protocol behavior; the local stack defaults to a mock provider. Production deployment and measured cost savings are not established by this overview.

AgentOps Canvas · orchestration workspace

A visual workspace for composing agents, tools, and infrastructure, validating connections, inspecting jobs, and generating artifacts. The implementation includes a React Flow editor, structured operations, validation rules, and tests for workspace changes.

The current MVP uses deterministic AI responses and simulated job execution. It demonstrates the interface and control model, rather than a deployed autonomous workforce.

AI analytical terminal · structured decision support

A keyboard-oriented terminal prototype combining panel navigation, data adapters, stored workspace state, and a model-analysis interface. Analysis prompts constrain numerical claims to the supplied quote data and organize the response into context, risks, and next considerations.

The default analysis stream is mocked. The project explores turning data into usable information; it does not establish trading results or independently verified forecast quality.

AI document pipeline · generated content & review

A Python publishing pipeline that turns structured Markdown into styled PDFs with contents, worksheets, and reusable layouts. An optional model-review stage produces recommendations, retaining the original output and feedback as separate artifacts.

The implemented review stage appends recommendations rather than proving the original content has been corrected. Editorial judgment and factual checking remain separate from file generation and page-count validation.

Applied agent research has also produced exploit analysis, reproduction scripts, validated findings, and supporting evidence. See my published PHP2Shell contribution →

Original development · Prototype · 2025

AI/RBAC identity,
policy & audit prototype

Explore how roles, decisions, and evidence fit together.

I developed a prototype spanning a Python API, Solidity contracts, and a dashboard. The contracts implement role grants and revocation, policy metadata, and authorized submission of audit anchors; API components explore identity-linking and attestation workflows.

The work makes an architectural question concrete: who can change a role or policy, and what record can another component inspect afterward? Source-level deliverables include a role registry, audit contract, API models, and tests for selected request flows.

Implementation boundaries

This is a proof of concept. The API’s signing helper is a deterministic test stub, policy compilation is mocked, and some policy checks are simplified. Those paths do not establish production cryptographic assurance or a complete authorization engine.

On-chain deployment, production integrations, and an independent security audit are not established. An audit anchor can reference a record; it does not prove that the record’s assertions are true.

Python API · Solidity · Role registry · Policy metadata · Audit anchors

Implemented components · prototype scope
  1. Role & policy registryMembership, policy metadata, grant/revoke events
  2. API & attestation workflowIdentity-link and audit payload interfaces; stubbed signing
  3. Audit referenceAuthorized reporter checks and anchor events

Component overview, not a claim of end-to-end production enforcement.

Earlier open-source work

SecDevOps Toolkit ↗ brings together provisioning code, configuration examples, and guides for repeatable environments.

CyberCloud ↗ explored a virtual security toolbox built around existing offensive and defensive technologies.

These projects reflect a continuing interest: automate the setup, make the environment reproducible, and give other people a useful starting point.

AI, security & engineering

Engineering capabilities

Prompt engineering, agents & full-stack AI delivery

Prompt engineering is a core part of my practice: I define the task, supply technical context, set constraints, connect tools, and specify the evidence a result needs. I use AI for reverse engineering, code creation, and full-stack development—from interfaces and APIs to persistence, infrastructure, debugging, and tests.

I use execution records, evaluation, and review to identify failures and refine prompts, configuration, and workflows. This includes prototypes for approval controls, usage visibility, and reviewed training-data candidates; improvement comes from examining results and testing the next change.

Early AI research archive, 2022–2023 →

Reverse engineering & exploit analysis

I work backward from software behavior to understand execution paths, prerequisites, and failure conditions. My research includes source analysis, executable and memory analysis, packet captures, custom protocols, and serialized payloads.

Exploit analysis and controlled reproduction help separate a vulnerable component from a reachable, exploitable condition. Challenge and lab work also give me a place to investigate unfamiliar systems and document findings, unsuccessful attempts, and remaining questions.

PHP2Shell: exploit validation in practice ↓

Nessus detection, exposure & identity

I’ve authored and published numerous Nessus direct checks over the years, researching vulnerabilities and developing detection logic across web applications, routers, databases, queueing applications, and network services. I investigate ports, configuration, and protocols such as GIOP, RMI, and LDAP to understand what an exposure allows an attacker to do.

I was a core author and contributor to Tenable’s AI-aware shadow-detection campaign. My contribution included bulk scripting and plugin-development workflows that helped establish initial detection capabilities, metrics, and insight for Tenable customer organizations worldwide. My role was part of Tenable’s collaborative research and engineering effort.

I connect that analysis to defender-facing detections and practical checks, with attention to false positives and reproducible evidence. I’m CISSP certified, with strong identity and access management expertise spanning Active Directory, authentication, authorization, and access controls.

Published Netlogon investigation ↗

Technical forensics & reconstruction

I build tooling to reconstruct what happened across AI sessions, tool actions, and generated artifacts. Local implementations connect source references, timestamps, session records, artifact snapshots, and hashes so an investigation can follow the evidence back to its origin.

Hash-linked journals and integrity checks help inspect retained records; recovery checks and explicit coverage gaps help explain what those records can support. I use that history to reproduce failures, compare versions, and explain a result.

Reverse engineering & forensics →

Quality assurance & test engineering

Quality engineering is part of how I build. I connect requirements to expected behavior, implementation, and test evidence through structured specifications, behavioral scenarios, and traceability checks.

My projects use unit, integration, regression, interface, and smoke tests, alongside failure and recovery scenarios. I test locally, inspect the running result, and use what breaks to improve both the implementation and the checks around it.

Research example: checking an AI-generated exploit claim ↓

Courseware & knowledge systems

I build learning platforms and content pipelines that connect structured course material, lessons, quizzes, and learner workflows. Local projects include LMS integration, automated intake, generated learning artifacts, validation, and review points.

That work draws on hands-on teaching and lab development: explain the system, give someone a way to practice, and check understanding. Technical documentation and operator training make the implementation easier for others to use and maintain.

Software engineering & technical leadership

I connect architecture to implementation: APIs, data models, persistence, configuration, infrastructure automation, and the work needed to launch and troubleshoot a running system.

My background spans enterprise systems, business intelligence, quality engineering, cloud infrastructure, and security. I contribute through hands-on development, technical direction, code review, mentoring, and clear documentation—working with other specialists and existing platforms to solve problems across those boundaries.

From implementation
to running system.

I develop iteratively: write code, work with coding agents, test locally, commit changes, launch the implementation, and inspect the running result. That direct feedback informs the next change. Code review and collaboration are separate activities.

  1. UnderstandProblem, constraints, expected behavior
  2. DesignArchitecture and a workable approach
  3. ImplementCode, prompts, and coding agents
  4. Test locallyReproduce, inspect, and debug
  5. Commit & pushVersion the change
  6. Build or launchRun the implementation
  7. VerifyTest the running system
  8. Refine ↺Use the result to improve the next change

Get in touch

Have a challenge
worth solving?

Start a conversation about engineering, research, or a problem that needs a closer look.