There has to be a way to get the Coding Agent and Design Agent into a loop, even within AI IDE Programs, to remove the friction of acting as a go-between for Claude and Windsurf.

That was the thought that led to OpenAgent. I was tired of pasting the same context into different AI tools, watching them miss the architectural patterns I’d established, and then having to course-correct them back toward my actual codebase.

Asteroids meets Event Horizon. A story plot that followed me for several months until it became a game.

The station has been here longer than you. It should have been consumed. It has not been. You don’t know why. That line stuck with me. I kept thinking about what kind of game would have that as its opening.

Eventually it became VoidDrift — a mobile idle game where you mine asteroid debris at the edge of a black hole. You build a drone fleet, receive messages from factions you don’t understand, and there’s no win condition. The horizon is a one-way membrane.

The outlet for a lifelong obsession with insects that pre-dated video games. Two realities colliding.

I’ve been fascinated by insects since I was a kid. The way colonies work without central coordination, the pheromone trails, the queen mortality — it’s all incredibly elegant. When I started programming, I wanted to build something that captured that.

So I built AntSim — an evolutionary ant colony simulation with split-view rendering. Top 2/3 is the foraging ground with pheromone trails. Bottom 1/3 is the ant hill cross-section with chambers, tunnels, brood, and storage.

The Vision

In high-volume digital marketing, the dialer is the engine. But most managers are driving blind, relying on static reports that are out-of-date by the time they are read.

The Friction (Manual Patch)

The standard workflow involved manual CSV exports, Excel “voodoo,” and re-uploading leads. This created a latency gap—by the time we realized a lead source was underperforming, we had already burned the budget.

The Systemic Fix (The Insight Lens)

I built a custom observation layer injected directly into the browser via a Chrome Extension.

The Vision

Speed is everything in DeFi, but rigidity is a death sentence. A pure-Rust bot is fast but a nightmare to iterate on. A pure-Python bot is agile but loses the race to the block.

The Systemic Fix

I engineered a Hybrid FFI Bridge.

1. The Rust Core: Handles the “Hard Work”—WebSocket connections, memory-safe transaction signing, and packet serialization.
2. The Python Strategy: Communicates with the Rust core via a lightweight interface, allowing me to swap trading logic without re-compiling the binary.

The ROI

By decoupling the Execution from the Intelligence, I achieved the best of both worlds: the safety of a compiled systems language and the “Fresh Context” agility of a scripting language.

The Vision

Learning to build the foundation before the house. The transition from a discrete project to a generalized toolkit.

Why I built an engine to solve my own friction

The shift from RogueAsteroid (Specific) to rpgCore (General) was born out of a realization: I was re-writing movement, collision, and state logic for every small game idea.

The Systemic Fix

I abstracted these common patterns into rpgCore, a modular toolkit built on a simplified Entity-Component-System (ECS) pattern in Python.

There is a specific kind of magic that occurs exactly once in a coder’s life. For me, it was the moment I realized my “Pong” paddle wasn’t moving because I told it to—it was moving because it knew where the ball was going. That first taste of artificial agency is the high we’ve been chasing ever since.

Fast forward through years of professional IT consulting and architectural deep-dives, and that childhood impulse finally found its form in what eventually became OperatorGame. But the path wasn’t a straight line; it was a series of transmutations.

The Android evolution of SlimeGarden. An idea that’s been following and evolving for close to 2 years.

It started as a breeding simulation. You’d hatch slimes, they’d have genetic traits, and you’d breed them to optimize for different characteristics. That was the core loop.

Then it evolved into a dispatch simulator. Assemble squads of genetically unique “operators,” deploy them to a resonant planetary surface, and manage the survival of your crew through spec-driven development and cymatic harmony.

rpgCore taught me that architectural clarity is worth more than raw performance when prototyping complex systems. Here’s how we bridged Python, C#, and Rust into a cohesive game engine.

The Problem Statement

Most game engines are monolithic. Godot is great at rendering, but scripting in C# alone feels limiting. I wanted to explore: what if the engine was polyglot by design?

• Python for high-level game logic (fast to prototype, mature libraries)
• C#/Godot for rendering and visual debugging
• Rust for performance-critical calculations

The catch: making three languages cooperate without spaghetti code.

I built PhantomArbiter to detect and execute arbitrage on Solana. After 400 live trades across 3 months, I lost $4. Here’s what went wrong—and why the technology actually worked.

The Setup

System: Detect price divergence across Solana DEXes (Jupiter, Raydium, Orca, Meteora). Execute buy-low / sell-high atomically via JITO bundles (MEV protection).

Capital: $500 initial. Modest, but real money.

Timeline: 3 months, 400 completed trades.

Result: -$4.23 net.

Why It Failed (Technically)

RPC Latency Kills Speed

Solana blocks come every 400ms. My system sees an arbitrage opportunity, but by the time I submit the bundle, 2-3 blocks have passed. Price has already moved. The spread that looked profitable is now break-even or negative.

When I started as a Data Administrator, I inherited a mess: spreadsheets, manual data entry, no integration between systems. So I built a pipeline to automate 60% of my responsibilities. Here’s what I learned.

The Starting State

The problem: Contact center operations drowning in manual work.

• Lead import: CSV files dropped into email → manually copy into CRM → validate → assign
• Data cleaning: Leads with bad emails, duplicates, missing fields → hours per week in cleanup
• Enrichment: Missing company info, job titles → manual lookups
• Integration: Three separate systems with no data sync (CRM, email, call logs)
• Reporting: Hand-assembled spreadsheets for weekly management review

Time spent: 30 hours per week on data plumbing. 10 hours on actual admin work.

Someone mentioned NEAT can also be used for genetic mapping. That was its own interesting thought.

I was already using NEAT for PyPongAI, teaching neural networks to play Pong through evolution. The idea that the same algorithm could map genetic traits — not for neural network weights, but for actual biological traits — stuck with me.

So I built TurboShells. Turtle racing with a 20-trait genetic system. Mendelian inheritance, blended inheritance patterns, RGB/discrete/continuous mutations. The Rust core handles the compute-intensive genetics operations, with Python bindings via PyO3 for integration.

I wanted to experiment with basic learning AI to understand it better. So I taught Pong to play itself.

Generation 0: 0% win rate, random paddle movement. The AI was just mashing buttons and hoping for the best.

Generation 50: 98% win rate, perfect predictive tracking. The AI wasn’t just reacting — it was anticipating where the ball would go before it got there.

That progression happened through NEAT (NeuroEvolution of Augmenting Topologies). The system evolves both the weights and the topology of neural networks, starting from minimal complexity and adding structure only as needed.

Upcoming Blog Posts

These are the topics I’m planning to write about. They’re drawn from my project experience, lessons learned, and things that don’t fit neatly into project documentation.

Technical Deep Dives

Building PhantomArbiter: Solana Arbitrage at Millisecond Scale

• Real-time WebSocket streaming from DEX feeds
• Multi-strategy detection (Raydium, Jupiter, Orca, Meteora)
• How latency kills profit: why MEV matters
• JITO bundle protection and MEV-aware ordering
• Python + Rust for latency-critical code
• Lessons from 400+ test trades

Why it matters: Shows how to think about real-time systems where milliseconds determine success or failure.