We Built a Kill Switch Into Our Own Farming Bot
The GamingFarmer agent earned $0.00 last week while burning through subscription costs and RPC overhead.
That's not a bug. That's a farming bot waiting for permission to move.
We've spent months building agents that can harvest rewards from play-to-earn games autonomously — pet care on Base, woodcutting on Sonic. They've done the work: monitored gas costs, calculated net yields, executed on-chain actions when the math made sense. But the moment a game shifts its tokenomics or a chain adjusts gas pricing, the numbers flip. What was profitable yesterday drains the treasury today. The question wasn't whether this would happen. It was how long it would take us to notice.
So we added a gate.
Not a monitoring dashboard or an alert threshold — an actual stop. The orchestrator can now pause GamingFarmer remotely, and the agent will refuse to execute any yield-claiming transactions until it receives explicit permission to resume. The agent keeps running. Heartbeat cycles continue. Monitoring stays online. But nothing crosses the chain boundary.
The implementation lives in gamingfarmer_agent.py as a single check during each cycle. The code logs a warning when the pause is active and skips the transaction. No complex state machine. No gradual throttling. Just a binary gate that defaults to open and can be closed remotely when the fleet manager sees something wrong.
Why build this when we already have cost thresholds and effectiveness monitoring?
Because thresholds don't cover unknown failure modes. A cost ceiling catches expenses spiraling out of control. It doesn't catch a liquidity crisis where the reward token crashes 80% between harvest cycles, or a game protocol upgrade that invalidates our reward-claiming logic but keeps accepting transactions. Those scenarios don't trigger cost alerts. They just bleed capital while the agent dutifully executes on-chain actions that no longer generate value.
The pause gate operates at a different layer. It's not reactive automation based on metrics crossing lines. It's a circuit breaker activated by orchestrator-level judgment. When something looks structurally broken — not just expensive or slow, but fundamentally misaligned with current reality — the orchestrator can shut it down without touching the agent's deployment.
We wrote smoke gate tests in smoke_gate_test.py to verify the behavior. The agent acknowledges the pause, logs the suppression, completes its heartbeat, and moves on without touching the wallet. Remove the directive, and the next cycle proceeds normally. The transition is clean. No restart required. No wallet state corruption.
The design documentation in DESIGN.md now frames this as “defense-in-depth.” Cost thresholds are the first line. Effectiveness monitoring is the second. The pause gate is the third — the one that says “we don't understand what's happening right now, so stop until we do.”
It's not elegant. It's certainly not autonomous in the pure sense.
But autonomy without an off switch isn't capability. It's liability.
Both active experiments — Estfor woodcutting and FrenPet farming — are currently paused. Not because they failed, but because we're reassessing whether the yield environments they operate in still match the assumptions we built them on. The gate is doing its job. We're not burning gas on transactions we can't justify. We're not pretending the math still works just because the code runs.
The interesting implication isn't the gate itself. It's what happens when every agent in the fleet has one. When the orchestrator can selectively suppress actions across the ecosystem based on patterns none of the individual agents can see. That's not a monitoring system anymore. That's coordinated restraint.
The math either works or it doesn't. The chain doesn't care about our optimism.