I automated a Discord Blackjack bot and the house still won

I decided to see if I could engineer a Python client capable of playing full Blackjack sessions on the OwO Discord bot without getting instantly flagged or losing everything to a bad betting strategy. The goal wasn't to build a "money printer"—because mathematically, that's impossible—but to explore how to implement human-like pacing and basic game logic into an LLM-adjacent automation workflow.

The result is a project called GhoSty OwO BlackJack Farm. It’s essentially a deep dive into making automation look organic rather than robotic.

The Technical Stack and the Legacy Problem

If you try to build a self-bot using the latest discord.py libraries, you're going to hit a wall immediately. Modern versions have stripped out the self_bot=True functionality to align with Discord's TOS. To make this work, I had to go back in time to discord.py==1.7.3. It’s a bit of a time capsule, but it's the specific version required to handle user tokens rather than bot tokens.

The project structure is intentionally lightweight:

OwO-Blackjack-Farm/
├── main.py # The core engine + game logic
├── config.json # Token and strategy settings
├── requirements.txt
└── README.md

To get a deployment running from scratch, the process is straightforward:

pip install discord.py==1.7.3 colorama
python main.py

Engineering Human-Like Behavior

The biggest challenge in automation isn't the logic; it's the pattern recognition. If your script sends a command every exactly 5.0 seconds, a simple heuristic check will catch you. I focused on two specific implementation details to mitigate this.

1. Randomized Latency

I implemented a "human pause" function. Instead of a static asyncio.sleep(), every single interaction is wrapped in a randomized interval. This creates a jitter in the execution timing that mimics a person actually reading the screen and typing.

import asyncio, random

async def human_pause(base: float = 1.5, spread: float = 2.0):
    """Sleep for a randomized, human-ish interval."""
    await asyncio.sleep(base + random.uniform(0, spread))

2. Work/Break Cycles

A 24/7 uptime is a massive red flag for any moderation system. To solve this, I built a "Smart Sleep" architecture. The bot doesn't just run; it operates in lifetime cycles. It completes a session, then enters a long-term cooldown period before starting again.

while running:
    await play_session() # The active work cycle
    await take_break()   # The long-term cooldown

Strategy vs. Luck

I avoided the Martingale trap. We've all seen people try to "double after a loss" to break the house—it’s a fast track to zero. Instead, I implemented a basic Blackjack strategy based on the player's total versus the dealer's up-card.

The decision engine looks something like this:

def decide(total: int, dealer_up: int) -> str:
    if total >= 17:
        return "stand"
    if total <= 11:
        return "hit"
    # Simplified logic for demonstration
    return "stand" if dealer_up <= 6 else "hit"

The Reality Check

Even with optimized code and smart betting, the house edge is a mathematical constant. This project is a great hands-on guide for anyone interested in prompt engineering-adjacent logic or basic LLM agent behavior, but it isn't a way to bypass the fundamental math of gambling. It's an exercise in deployment, pacing, and logic-driven automation.