Autonomous Decision Systems With Real Money on the Line
Most teams deploying autonomous agents can tell you the agent ran. Almost none can tell you whether it should have.
That gap is survivable when the agent drafts emails. It becomes expensive when the agent moves money. I built PolyTake to trade prediction markets unattended, against real counterparties, with onchain settlement. A month ago I wrote about the supervision, journaling and calibration that required. The next month exposed a harder question: what evidence would justify letting the system trade at all?
As of 9 October 2026, the current runtime is dry. It observes live markets and maintains separate virtual accounts; it does not send funded orders. The latest measured paper cohort is negative after fees. That is part of the result. A reliable agent can execute a losing idea reliably.
Objective
Build an agent that can operate continuously, and instrument it well enough to reconstruct what it saw, why it acted or refused, whether the action was executable, and what eventually happened to the inventory.
The unit of evidence is a decision with its inputs, clocks, policy version and outcome. A running process is only the beginning.
Architecture
- An async daemon with supervised tasks for discovery, reference prices, quotes, depth, decisions and accounting
- WebSocket feeds for changing prices, with bounded REST recovery for full order books
- Separate source-event, local-receipt and application clocks, so freshness has a measurable meaning
- Bounded recording queues, durable SQLite journals and explicit failure states when evidence is lost or delayed
- Risk limits, capital reservations and a hard halt, with virtual accounts isolated from historical real trading state
- Heartbeat logging that includes reject reasons, recording health and useful depth coverage
The important revision is the recorder. Moving writes away from the decision path does not make them infallible. A queue can overflow. A worker can fail. A crash can lose records that were accepted into memory but not committed. If the system cannot retain the evidence required to justify an entry, that failure must participate in admission control.
Likewise, a connected socket can deliver fresh best prices while full-size depth is missing or old. Recent checks showed exactly that. Connectivity, quote freshness and executable-book freshness are separate measurements.
The model is deliberately simple
The baseline is a zero-drift geometric Brownian motion model. Given a positive current price S, reference K, annualised realised volatility σ and time to expiry T in years:
d₂ = [ln(S/K) − ½σ²T] / (σ√T)
q = P(S_T > K) = Φ(d₂)Here Φ is the standard normal cumulative distribution function. Zero drift refers to the price process; the log-price expression still contains the −½σ²T correction. This is a baseline estimate of an outcome probability, not proof that the market is wrong.
An early version extrapolated the recent move into a drift estimate. Over a much longer horizon that could manufacture confidence the evidence did not support. Removing that term removed one source of overconfidence. It did not establish calibration.
The contract's resolution rule matters just as much as the equation. A model of a terminal spot price does not automatically price a contract settled on a trailing average. Nor are a spot feed, an oracle average and a price from another exchange interchangeable. The current paper comparisons retain asset, horizon and price-source labels for that reason.
The pricing remains simple on purpose. The work is in testing its assumptions against the exact contract and the prices we could actually obtain.
Break-even includes the bill
A binary paying $1 bought at price p has a gross break-even win rate of p. The relevant benchmark includes acquisition costs. For a hold-to-resolution trade, let c be the all-in cost per share and q the true win probability:
c = executable purchase price + entry fee + other acquisition costs
E[profit per share] = q − c
break-even: q = cPolymarket's current fee documentation gives the taker fee as C × r × p × (1 − p), where C is shares and r is the market fee rate. Market parameters must be read rather than assumed. With r = 0.07, a $0.55 purchase costs $0.567325 per share before other costs: a 56.7325% break-even probability.
Early exits change the accounting again. Selling consumes a bid and may incur another fee. Buying the complementary outcome and merging consumes an ask and additional capital. The relevant comparison is the net executable value of each available route, subject to size and budget.
A model probability above the ask is therefore a hypothesis about edge. It becomes useful only if the probability is calibrated, the quantity is obtainable, and the eventual result survives costs. Prospective rewards or rebates do not belong in realised profit before they are earned.
Count the stages, not just the trades
“The bot is trading less” can mean several different things. It may observe fewer markets, qualify fewer decisions, lack fresh depth, prepare fewer orders, or fail to obtain fills. Those explanations require different remedies.
Every arrow needs evidence
Recorded market → Qualified decision → Executable size → Prepared intent → Confirmed fill → Settled result
Live orders also need submission, acknowledgement and reconciliation records. Paper fills remain simulated depth proxies throughout.
One correction in the research was particularly useful: a proposed purchase entered in the venue's interface had never been completed. It was a quote, not a fill. It could not demonstrate that the interface had execution priority over the API.
Another audit found paper entries failing even when the later best ask was equal or better. That did not establish a bug. The simulation also required a newer, fresh depth snapshot and the full intended quantity inside the original limit. Historical records lacked enough depth diagnostics to distinguish all those failure reasons. The honest answer was “unmeasured,” followed by better instrumentation.
Aggregate rejection counts are useful for health checks, but gates overlap and a market can be rejected repeatedly. A causal funnel needs distinct market or intent identifiers and coverage over the same interval.
Journaling the refusals
Record the gate that blocked a decision, the price and size under consideration, model inputs, source clocks and policy version. Then revisit those decisions after resolution.
The original counterfactual arithmetic still has a role. If y is the resolved payout, either 0 or 1, and c is the all-in acquisition cost, a hypothetical hold-to-resolution result is:
hypothetical profit per share = y − cBut that calculation assumes the purchase could have happened. A rejected quote with no executable-size evidence cannot be promoted into a missed profitable trade. Replay also needs the decision clock, realistic execution delay, capital availability and the sequence of other positions. Missing evidence stays missing.
This distinction changed one apparently clean historical result. More precise timestamp handling restored a losing candidate that an earlier replay had excluded. The replay looked better because the measurement was wrong. Correcting the clock mattered more than improving the headline.
Refusal analysis should tell us which guardrails deserve further testing. It should not manufacture fills that never existed.
Calibrating on a lower bound
Bucket resolved decisions by estimated probability, acquisition cost, asset and horizon. Alongside sample count and observed win rate, calculate the lower endpoint of a Wilson interval. For n observations, win fraction p̂ and z = 1.96:
p̂ + z²/(2n) − z√[p̂(1−p̂)/n + z²/(4n²)]
lower = ───────────────────────────────────────────
1 + z²/nThis is the lower endpoint of a two-sided 95% interval, following the Wilson construction. It penalises small samples. It does not make lucky streaks impossible, repair a biased sample, or turn correlated observations into independent trials.
Compare the lower bound with the bucket's actual acquisition economics. Where costs vary materially or trades exit early, inspect fee-net trade outcomes directly. A win-rate interval alone does not describe that strategy's return.
Tightening can require less evidence than loosening, but both are policy choices. Any proposed relaxation needs a later holdout, unchanged evaluation rules and an accounting of missing observations. Repeatedly selecting the best thresholds on the same history is another way to buy confidence cheaply.
The output remains advisory. A human reviews the evidence and approves a policy change. Autonomous execution does not require autonomous retuning of risk limits.
Latency is an execution question
Stale offers are attractive only if they remain obtainable when an order reaches matching. A fast local loop does not establish that. Source age, application delay, signing, network travel and venue processing all sit between the signal and execution.
The venue's predictions changelog documents a 150 ms crypto taker delay effective 4 September 2026. That published hold is separate from end-to-end order latency. Our 500 ms paper reaction is a simulation assumption, not a measurement of the venue's total delay.
A separate observer now checks already-qualified intents at 150, 250 and 500 ms, keeping the original quantity, price limit and fee assumptions. Late samples or missing fresh depth are labelled unmeasured. Full displayed size is an availability proxy, not a confirmed fill.
The first observations established that the measurement path worked. They did not show an earlier-only opportunity. They also cannot see opportunities rejected before qualification because depth was unavailable. That selection boundary belongs in the result.
Even repeated evidence that an offer disappears would leave a second question: are the offers we can capture profitable after fees and settlement? Faster acquisition can improve execution of a good signal. It can also accelerate adverse selection.
Exits have to be executable too
The recent paper losses made inventory control a central research question. A position can deteriorate long before settlement, but a stop trigger is not an executable exit price or a maximum-loss guarantee.
We compared sampled quote deterioration with adverse movement in the underlying. Some eventual full losses were flagged, often late. Some eventual winners were flagged too. Sparse observations could not establish continuous confirmation or full-size delayed exits, so the screen did not justify a counterfactual profit claim.
A proposed exit must be tested against the winners it cuts as well as the losses it avoids. It needs fresh bids or complementary asks, enough size, available hedge capital and all execution costs. Detecting danger is useful; containing losses does not guarantee positive entry economics.
Validating against an external source of truth
Historical funded trading still needs reconciliation against venue and chain evidence. Join durable order records, execution events and accounting by full venue order identifier. Partial fills, cancellations, redemption and inventory changes are distinct events. A position disappearing from an API response is not sufficient proof of a sale or settlement.
The instrumentation itself needed auditing too. In an earlier accounting bug, a worthless position was recorded when written off locally and again when redemption completed. Both rows carried the full loss. Summing them double-counted the economic event.
The remedy is an auditable lifecycle with one economic result, separate operational events and explicit fee treatment. A terminal wallet balance, a journal row and a dashboard total should be reconcilable, rather than three competing versions of the truth.
Paper accounts remain separate. Their simulated outcomes can reject a hypothesis or expose a measurement defect. They cannot certify real execution, queue position or wallet returns.
Where this connects to my day job
I drive this work at Scalytics, where we build Lascaris, a sovereign operating system for AI agents. Its architecture brings together event streaming, agent execution, shared memory and a durable audit trail. The open core includes KafScale, the S3-native Kafka-compatible transport.
PolyTake is where I test the operational requirements on myself: retain the context behind a decision, reconstruct an action later, identify missing evidence, and reconcile the reported result with an external record. The trading daemon does not run on Lascaris; this is an engineering testbed for the same accountability requirements.
The execution path and the audit path also have different latency needs. Durable history belongs in reliable storage. Time-sensitive admission needs fresh local state. Designing those paths deliberately is more useful than claiming one transport should serve every workload equally well.
Finance, defense and energy operators face different outcomes, but a common question: can somebody who was not there reconstruct why the agent acted, and assess whether its inputs and authority justified the action?
What transfers
- Procurement: which requests were refused, and did the refusal prevent waste or block necessary work?
- Fraud review: what evidence supports the blocked decision, and how are false positives revisited?
- Incident response: was silence a deliberate decision, or a broken observation path?
- Content and compliance: which cases were accepted or rejected, and which outcomes remain unknown?
Markets provide a settlement result. Other domains need an explicit outcome-review process. In both cases, refusal records, coverage checks and reconciled accounting make thresholds testable.
Why the social media praise still don't add up
A high win rate is easy to market when the payoff ratio is omitted. Buy a $1 binary at $0.99 and you risk $0.99 for a gross cent. Before costs, one full loss erases ninety-nine wins. Break-even is 99%; at a 98% win rate, expected gross profit is negative.
But that arithmetic does not prove every expensive favorite is unprofitable. Nor does a thin book prove nobody can trade it. The correct question is whether a specific strategy clears its own costs at obtainable prices and sizes over an independent sample.
The socials and "bot makes 2M in month" with screenshots usually cannot answer that. It may show last price rather than executable depth, selected winners rather than a complete cohort, or wallet-level returns combining different strategies. Realised trading profit, earned rebates, rewards and unresolved inventory need separate accounting.
The same applies at the cheap end. A one-cent contract needs a true probability above its all-in cost to have positive expected value. Being cheap is not evidence of mispricing. Increasing size after a fall needs a new justification, not a more flattering entry average.
Turnover is constrained by the eligible universe, time windows, capital and depth. Faster recurring markets provide more possible decisions than daily ones, but recurring opportunities are not unlimited executable capacity.
The recent research supports a narrower conclusion than either a rising dashboard or a blanket declaration that all new bots must lose: this measured paper strategy has not demonstrated a profitable edge. Further infrastructure work must be judged by the evidence it enables, and further strategy work by independent fee-net outcomes.
Notes
This system is private. Entry criteria, parameter values and performance figures are not disclosed here. The public examples explain the engineering and arithmetic; they are not a trading recipe. The two screenshots are retained from the original article and represent that earlier view, not the current dry runtime.
Updated 9 October 2026. Operational statements reflect the dated research and deployment checks available for this revision. Venue rules and fee schedules can change.
Running agents in production and unsure whether your guardrails are helping or hurting?