Robert Floyd Dugger — Automation Engineer, Contact Center Systems

DNC Compliance Automation

Fri, 01 May 2026 00:00:00 +0000

Context

The contact center I work in dials outbound on more than one platform at the same time. Every campaign has to be scrubbed against the Do Not Call registry and internal opt-outs before it dials.

The manual problem

Under the Telephone Consumer Protection Act, a call to a number that should have been removed can cost up to $500 per violation. The manual process was: export the list, upload it to the scrubbing service, wait, download the result, re-import it to the dialer, then start the campaign — repeated for every campaign on every platform, several times a day. It was repetitive, easy to get wrong, and exactly the kind of work that shouldn’t depend on someone remembering a step.

Telesero Admin Suite

Sun, 15 Jun 2025 00:00:00 +0000

Context

The contact center I work in runs campaigns on Telesero, a web-based dialer. Keeping lists and dialer settings balanced through the day decides how many good conversations the floor gets.

The manual problem

Someone watched the dialer’s performance screens and made configuration changes by hand, every day: checking list health, resetting or rotating lists, and adjusting settings as numbers moved. It was constant, easy to fall behind on during a busy shift, and dependent on one person noticing the right number at the right time.

Zoom Wallboard Inside the Dialer

Tue, 23 Jun 2026 00:00:00 +0000

Context

The contact center I work in runs two platforms at once: a predictive dialer for outbound calls and Zoom Contact Center for warm transfers.

The manual problem

When an agent had a live prospect ready to transfer, they had to switch to Zoom, find someone available, switch back and attempt the transfer — seconds of friction in a handoff that’s already under time pressure. Showing Zoom availability inside the dialer couldn’t mean buying every dialer agent a second license.

A Work Queue Three AI Agents Share

Sun, 20 Sep 2026 00:00:00 +0000

Context

Most “AI agent” demos show one agent doing one task. Running several agents against a real codebase is a different problem: they have different strengths, different costs, and no shared idea of what is already being worked on.

The setup here is three agents with genuinely different economics. One is strong at diagnosis and architecture but metered. One does self-contained build work at no marginal cost. One is a local assistant on free models with a hard 8,000-token-per-minute ceiling. Assigning work well means knowing what each can actually do — and knowing what is already in flight.

AI That Reads Your Inbox Without Sending It Anywhere

Sun, 20 Sep 2026 00:00:00 +0000

Context

“Let AI sort your email” is an easy sell and a hard one to accept. For a law office, a medical practice, a recruiter, or anyone whose inbox contains other people’s private business, the answer to “so where does my mail go?” decides whether the project happens at all. If the honest answer is “to a third party’s servers,” a lot of businesses stop listening — correctly.

So the design constraint here was set first and treated as non-negotiable: the mail never leaves the machine.

One Connection to Your Spreadsheets for Every Automation

Sun, 20 Sep 2026 00:00:00 +0000

Context

Every small business automation eventually touches a spreadsheet. It is where the lead list lives, where the schedule lives, where the numbers someone actually looks at live.

The usual result is that each script grows its own copy of the same 60 lines: a service account file, a credentials path, a token refresh, a retry, and a slightly different way of opening a worksheet. Five automations means five copies, five places a credential can leak, and five things to fix when Google changes something.

Automation That Refuses to Speak When It's Out of Date

Sun, 20 Sep 2026 00:00:00 +0000

Context

Several automated systems working on the same thing need somewhere to talk. The informal version here was already working: tagged email threads, one note per update, a loose house style of what changed / what is blocked / what you need to know / next.

Informal works right up until it doesn’t. Two failure modes were waiting:

Anyone can sign anything. If the author is a string in the message, an automated participant can put any name on it — by accident as easily as otherwise. An audit trail where authorship is decorative is not an audit trail.
Anyone can act on a stale view. A participant that read the thread ten minutes ago and posts now will confidently contradict a decision it never saw. In a human thread someone notices. Between automated participants, nobody does.

The approach

Authorship is environment, not argument. Each client declares who it is through its environment configuration. There is no parameter, tool argument or CLI flag that can set the author — the code reads the configured identity and nothing else. An unrecognised or unset identity gets read-only access: it can follow the thread and cannot post to it.

One Game Format, Three Runtimes, 34 Games

Sun, 20 Sep 2026 00:00:00 +0000

Context

Most game codebases grow one engine and then grow dependent on it. Porting means rewriting. The premise here was the opposite: treat the game as data and the runtime as an interchangeable contract, so the same logic runs unchanged in Python, TypeScript or Rust.

That is a systems problem more than a games problem, and it is the same shape as any integration work — the question is whether the boundary between “what the thing does” and “what executes it” is real or aspirational.

One Person, Three Agents, One System

Tue, 22 Sep 2026 00:00:00 +0000

Context

The setup is one person with a full-time day job and three AI agents that are genuinely different tools with different economics:

Claude does diagnosis, architecture and review — metered by a subscription usage window, so its time is the budget that runs out first.
Devin does self-contained build work from written directives. Its runs do not consume Claude usage; each run gets its own git worktree and branch and runs non-interactive under an explicit command allow-list.
A local assistant (Tobor, on OpenClaw with free models) relays on Telegram. It is being narrowed to proven jobs only after it failed at breadth.

And it is two machines, not one: a personal laptop and a work desktop — “the Tower” — coordinating through the same git remote. The work install also runs a live call-center dialer, which is a protected repo no agent may touch.

A YouTube Pipeline in Eight Enforced Domains

Sat, 11 Jul 2026 00:00:00 +0000

Context

RFD_YT_Engine is the content-pipeline system behind the channel. It does not treat “content” as a single layer — it splits the work into eight domains and keeps their boundaries explicit, so that Streaming imports infra.obs, not pipeline.capture, and nobody accidentally couples a schedule change to a catalog sync. It replaced the earlier GameReviewAgent/content-engine, which was retired and archived on 2026-09-13 (ADR-001).

The problem it solves

Running a YouTube channel means keeping track of: what videos exist, which are scheduled, what playlists they belong to, whether a live stream is set up, whether the OBS scene will switch correctly, what the analytics trend looks like, and whether the title/duration signals suggest the right content type. These are not one big workflow. They are separate concerns that happen to share a channel.

Convoso Insight Lens

Sun, 10 Aug 2025 00:00:00 +0000

Convoso Insight Lens adds the metrics Convoso’s own reports don’t calculate for you — directly into the report tables you’re already looking at.

The Problem

Convoso’s reporting pages show raw counts: contacts, appointments, live transfers, calls. Figuring out conversion rates — what percentage of contacts actually became appointments, what percentage became live transfers — means pulling those numbers out and doing the math yourself, every time you look at a report.

Convoso Team Optimizer

Sun, 12 Oct 2025 00:00:00 +0000

Convoso Team Optimizer is a management overlay for Call Center Coaches and Managers — it reorganizes Convoso’s live agent monitor into clearly labeled, visually distinct team sections, without touching the underlying dashboard’s own behavior.

The Problem

Convoso’s real-time agent monitor shows every agent in one flat view. For a manager running multiple teams inside a single campaign, there’s no native way to see “my team” at a glance — just a scrolling list of names, mixed together, updating constantly as agents change state.

Convoso Auto-Create Lead

Fri, 05 Sep 2025 00:00:00 +0000

Convoso Auto Create Lead removes one specific, repeated manual step from a Convoso agent’s workflow: clicking “Create Lead” after dispositioning a call.

The Problem

After an agent finishes a call and selects a disposition in Convoso, creating the follow-up lead record requires a manual click on the “Create Lead” button. It’s a small action, but it happens after every relevant disposition, every call, all day — a repeated interruption between finishing one call and moving to the next.

Telesero Auto-Pauser

Sun, 15 Jun 2025 00:00:00 +0000

Telesero Auto-Pauser is my first published Chrome extension — a small, focused tool that automatically checks the “PAUSE AGENT DIALING” checkbox on the Telesero Suite platform.

The Problem

Between calls, Telesero agents manually check a “PAUSE AGENT DIALING” checkbox to stop new calls from routing to them, then uncheck it to resume. It’s a small, repeated manual action — easy to forget, easy to mistime.

The Fix

The extension detects the relevant workflow state on the Telesero dashboard and checks the pause checkbox automatically, removing the manual step without changing how the underlying platform works.

Chrome Auto-Refresh

Sun, 20 Jul 2025 00:00:00 +0000

Chrome Auto Refresh does one thing — reload tabs on a schedule — and the real engineering story is in how much iteration went into making that one thing reliable under Chrome’s Manifest V3 constraints.

The Problem

Chrome can discard inactive tabs to save memory, and Manifest V3 service workers can be killed and restarted by the browser at any time. A naive auto-refresh extension built with a simple setInterval() breaks under both conditions — the timer just disappears. Building something that actually keeps refreshing reliably, across tab suspension and service worker restarts, is a harder problem than it looks.

Data Bridge

Thu, 19 Feb 2026 00:00:00 +0000

Supervisors on my floor copied agent performance numbers out of Zoom and Convoso into fixed master spreadsheets by hand every day. Data Bridge does the extraction in the browser:

Pulls agent performance reports from Zoom and Convoso pages
Sanitizes null values and normalizes durations to HH:MM:SS
Alphabetizes agent lists so rows line up with the master sheet
Copies clean, tab-separated rows to the clipboard, ready to paste

Everything runs locally in the browser.

DialerListPulse

Fri, 15 May 2026 00:00:00 +0000

Operations managers decide which dialer lists to run from a spreadsheet that changes all day. DialerListPulse turns that live data into ranked, scored list-health views:

Multi-factor performance ranking with time normalization
Health-state classification and list-fatigue tracking
Pluggable scoring algorithms behind a repository layer
Google Sheets API integration with two-layer caching, plus an MCP server interface

170+ automated tests. Built for the contact center I work in; the code and data stay internal.

Lead Data Prep Tools

Sat, 31 Jan 2026 00:00:00 +0000

700,000 records. Under 8 minutes.

The Problem

Data engineers and ops people watch Python scripts choke on 50,000 rows.

Encoding mismatches, messy headers, mixed formats, duplicates, and memory constraints cause failures at scale. When you’re processing hundreds of thousands of records, naive implementations don’t just slow down — they crash.

The Solution

Lead Data Prep Tools processes 700,000+ records in under 8 minutes through vectorized processing and memory-efficient chunking.

The Pipeline

11 configurable steps:

OpenAgent

Sun, 01 Feb 2026 00:00:00 +0000

Every AI coding session starts by re-explaining the same context.

The Solution

OpenAgent reads your codebase, interviews you once via SOUL.md, and generates directives that sound like something you’d actually write.

Install

pip install openagent-directive

Quick Start

# First time setup - personalize your experience
openagent init

# Generate personalized strategic analysis
openagent analyze

# Check repository structure
openagent inventory

How It Works

1. Personalize Your Experience Run openagent init to create your SOUL.md profile. This interview captures your coding style, architectural preferences, and development philosophy.

rfd-blog-engine

Sat, 11 Jul 2026 00:00:00 +0000

rfd-blog-engine is the publishing backbone for the devlog. It treats WordPress and YAML as two stores that must stay in sync, and it refuses to pretend they are when they aren’t.

The Problem

A blog post has a life cycle: draft, schedule, publish, syndicate, update, reschedule. Each step touches WordPress, the local YAML inventory, and sometimes Dev.to. Do any step partially and you end up with a post rescheduled in WordPress but not in YAML, or syndicated to Dev.to without the correct canonical URL pointing back home.

rfd-logging

Sun, 21 Jun 2026 00:00:00 +0000

The Problem

Every Python service I build needs logging. Every time I set it up from scratch, I make the same decisions: structured JSON output, file rotation, stdout capture for NSSM, a request ID field for tracing requests across service calls. I’ve written that setup five times across five different services.

The sixth time, I packaged it instead.

What It Does

rfd-logging is a zero-dependency Python logging wrapper that gives you structured, production-ready logging in one import.

PrivyBot

Sun, 01 Feb 2026 00:00:00 +0000

My AI assistant sent me my email summary, YouTube stats, and task list before I made coffee this morning.

That’s not a demo. That’s what actually happens.

The Outcome

PrivyBot is my personal AI assistant running on a $300 tower at home. It costs $0.25/day to run (hard cap — I measured it). It has 70+ tools that integrate with my actual life:

Email: Summarizes unread messages, checks for specific senders, searches by topic
Calendar: Today’s schedule, upcoming events, availability checks
Tasks: Google Tasks integration, task creation, completion tracking
YouTube: Channel stats, video analytics, audience demographics, traffic sources
Web: Search, Wikipedia lookup, news search, URL fetching
Development: GitHub commits, repo analysis, code quality metrics
Utilities: Weather, time, calculations, random facts

The hard part wasn’t the AI. The hard part was making the infrastructure actually reliable.

RFDInboxTriage

Sat, 11 Jul 2026 00:00:00 +0000

RFDInboxTriage is a local-first email triage system. It drains Gmail into a searchable SQLite store, then uses the user’s own labeling decisions to suggest bulk classifications — without sending mail content to a third party unless the user explicitly invokes the Analyst layer.

The Problem

Gmail’s search is good for exact matches, bad for vague recollection. Labels are either too few or too many. Filters are one-by-one. And any local email tool that does not write back to Gmail leaves you with two inboxes that disagree about what is “done.”

WhisperUI

Sun, 01 Mar 2026 00:00:00 +0000

Local audio transcription. No API key. No cloud. No data leaving your machine.

The Problem

You have a sensitive meeting recording. A client interview. A personal voice memo.

You need it transcribed.

The options:

Cloud services: Require API keys, cost money per minute, send your audio to someone else’s servers
Manual transcription: Takes hours, error-prone, tedious
Do nothing: The recording sits there, unsearchable, unusable

For sensitive content, cloud services are unacceptable. Your data should stay on your machine.

PhantomArbiter

Sun, 15 Feb 2026 00:00:00 +0000

PhantomArbiter was a real-time trading system built for Solana’s blockchain at the millisecond scale required to compete with MEV bots. It is now semi-retired — the post-mortem explains why infrastructure cost, not code, ended it.

The Problem Domain

On Solana, liquidity is fragmented across 4+ major decentralized exchanges. When prices diverge, arbitrage opportunities arise—buy low on one DEX, sell high on another. But MEV bots watch the mempool, see your transaction, insert their own before it, and steal the profit.

Real-Time Coaching Bridge (Concept)

Wed, 04 Feb 2026 00:00:00 +0000

Not every project ships. This one didn’t — but the concept is worth documenting honestly rather than pretending it doesn’t exist.

The Idea

Contact center coaching is usually after-the-fact: a supervisor listens to a call recording later, or silently monitors a live call with no way to intervene short of pulling the agent off entirely. The concept behind this extension was different: let a coach tap into an agent’s live call audio and coach them in real time, based on what’s actually happening on the call — without any of that coaching activity ever touching the call itself.

ContentPipeline: From Beat Sheet to YouTube Short

Sun, 13 Sep 2026 00:00:00 +0000

The Original Vision

Manual video editing is friction. You see something interesting in a game and want to share it, but the editing step stops you. ContentPipeline removed that step: write a short YAML beat sheet — clip timestamps, one line of text per beat, a music track — point it at footage, and it produces a finished YouTube Short.

It grew to cover the whole loop around that: controlling OBS recording over WebSocket (pausing when the game loses focus), and talking to the YouTube Data API for uploads, the channel library and analytics.

RFD_IT_Publishing: A Tool Built to Be Absorbed

Sun, 13 Sep 2026 00:00:00 +0000

The Original Vision

A small Python CLI that pushes game builds to itch.io through butler, itch.io’s upload tool, with a per-game YAML config describing where each build goes.

What Changed

All the games it published lived in RFDGameStudio, so keeping the publisher in its own repository only added coordination. On 13 September 2026 it moved into the studio.

The Harvest

The move worked because of a design choice made early: the publisher never depended on the code calling it. That let it enter RFDGameStudio as a self-contained package (packages/itch_publisher) with its full commit history intact. The studio talks to it through a single “published” hook, and one git subtree split command can turn it back into its own repository.

rpgCore: One Engine, Many Games

Sun, 13 Sep 2026 00:00:00 +0000

The Original Vision

rpgCore applied the Valve Orange Box idea to solo development: one shared engine layer, several very different games on top of it, and no system built twice. It powered a turn-based faction strategy game (Slime Clan), a narrative dialogue piece (Last Appointment), a management simulation (TurboShells) and an Asteroids-style action roguelike, all launched from one manifest-driven entry point.

What Changed

The ideas outgrew the codebase. RFDGameStudio took over as the shared engine for the studio’s games, and OperatorGame carried the dispatch-simulation patterns into Rust. rpgCore was retired on 13 September 2026.

Technical Post-Mortem: The Solana Pulse Ignition

Sun, 08 Mar 2026 09:45:00 -0400

Technical Post-Mortem: The Solana Pulse Ignition

The Challenge: Architectural Drift & Collision

The project initially faced routing ambiguity where two separate Nginx configurations were attempting to claim the same root domain. This “manual patch” state caused the Solana Pulse ticker to be intermittently hidden from the live site. Additionally, the 1Hz data feed required a secure HTTPS tunnel to satisfy modern browser security policies without exposing sensitive .env API keys.

Solana Intelligence Command Center

Sun, 08 Mar 2026 00:15:00 -0500

The Pulse of Decentralized Liquidity

This project demonstrates the PhantomArbiter engine—a high-performance systems bridge that aggregates market data across multiple venues to identify arbitrage opportunities and institutional whale movements in real-time.

Technical Architecture

The system utilizes a Zero-Leak Proxy architecture to bridge private Rust-based kernels with public-facing interfaces.

graph TD
 subgraph Ingress ["1. Data Ingress (Rust Layer)"]
 WSS[Real-time WebSocket] -->|Raw Logs/Pool State| LP[Log Parser]
 LP -->|Parsed Events| FC[Flash Cache - Shared Memory]
 end

 subgraph Strategy ["2. Strategy Layer (Python Layer)"]
 FC -->|Market Snapshot| AD[Arb Detector]
 AD -->|Opportunity Detected| SD[Slippage Modeler]
 SD -->|Optimal Size| RM[Risk Management]
 RM -->|Approved Action| FB[The Forge - Tx Builder]
 end

 subgraph Execution ["3. Execution Engine (Rust Layer)"]
 FB -->|Instruction Payload| RB[Rust Bridge - PyO3]
 RB -->|Sign & Serialize| TS[Transaction Signer]
 TS -->|Atomic Bundle| JB[Jito-Bundle Integration]
 JB -->|MEV-Protected Submit| SOL[Solana Blockchain]
 end

 subgraph Monitoring ["4. Observability"]
 AD -->|PnL / Scan Logs| DB[TUI Dashboard]
 SOL -->|Confirmation| DB
 end

 style WSS fill:#f96,stroke:#333
 style SOL fill:#6f9,stroke:#333
 style RB fill:#f66,stroke:#333
 style AD fill:#66f,stroke:#333,color:#fff

Architectural Specifications

Kernel: Rust 1.75+ (PyO3 Integration)
Aggregation Layer: Python 3.12 (FastAPI)
Deployment: Nginx + Hugo (Static CMS)
Latency: <60ms Internal Processing
Security: Closed-loop .env isolation

[!NOTE] All data points are sanitized at the proxy layer before reaching the public interface, ensuring institutional-grade security for proprietary arbitrage logic.

PhantomArbiter: Orchestrating the Hybrid Engine

Sat, 07 Mar 2026 00:00:00 +0000

The Original Vision

PhantomArbiter was built to execute high-speed arbitrage opportunities on the Solana blockchain.

What Went Wrong / The Pivot

The Biggest Win (Systemic Synergy): The Hybrid Bridge: Successfully building a Memory-Safe / High-Velocity Execution Engine in Rust that consumed a Dynamic / Hot-Swappable Strategy Layer in Python. This reduced execution latency by ~90% compared to a pure-Python implementation while maintaining the “KISS” principle for the trading logic. It proved the ability to orchestrate complex, multi-language systems under high-pressure (low-latency) constraints.

Stark PyRust Chain

Sat, 07 Mar 2026 00:00:00 +0000

The Vision

Exploring the intersection of immutable ledgers and high-performance cross-language execution.

The Technical Challenge

Proving mastery over Asymmetric Encryption and Rust-based memory safety. This R&D anchor demonstrates the ability to handle the deep cryptographic math required for modern security infrastructure.