AI Crypto Trading Agents Need an Operator of Record: A 12-Case Ownership and Kill-Switch Test
An AI trading agent should not be allowed to place a live order until one named human role can answer four operational questions without searching a chat history: who authorized this mission, what exact authority was del
An AI trading agent should not be allowed to place a live order until one named human role can answer four operational questions without searching a chat history: who authorized this mission, what exact authority was delegated, who can stop it now, and who reconciles the account after it stops. If any answer is “the team,” “the vendor,” or “the model,” the agent has no usable operator of record.
That recommendation is about operational control, not whether a strategy is profitable. A strategy can pass backtests and still have no safe owner when an API key is rotated, an order is partially filled, a model is changed, or the person who launched the process leaves. The Trustly AI guide to quantitative crypto backtesting is useful for separating historical simulation from live evidence. This companion addresses the next decision: whether the people and controls around an agent are ready to operate it at all. It does not recommend an asset, exchange, trade, leverage level, or expected return.
Use the 12-case protocol below as a tabletop acceptance test. It is a constructed checklist, not a study of trading systems, a security audit, or a result from a live exchange. Its sample is exactly twelve deliberately chosen failure and handoff scenarios, written on 18 November 2026. No customer data, accounts, API keys, exchange endpoints, strategies, model outputs, or production systems were tested. The value is repeatability: a team can run the same scenarios against its own runbook and record pass, fail, owner, evidence, and remediation. A “pass” means the control is demonstrated in the exercise; it does not certify regulatory compliance, security, or investment suitability.
The decision in brief
Start with a paper-only or read-only integration. Do not permit live order placement merely because a model produced plausible explanations, a backtest looks attractive, or a human can click an approval button. Before increasing authority, require all of the following:
- A named accountable owner and a named on-call substitute, both with authority to stop the mission.
- A mission record that binds the owner, strategy version, model and prompt versions, exchange account, allowed instruments, permitted order types, limits, start time, expiry, and evidence location.
- Credentials scoped to the minimum necessary permissions, with withdrawal and transfer disabled where the platform supports that distinction. A software policy is not proof that the exchange enforces the same limit.
- A stop procedure that blocks new orders, cancels eligible open orders, records uncertain or partially filled orders, and does not claim that cancellation reverses a fill.
- A reconciliation owner who compares the agent’s event log with exchange-confirmed balances, fills, and open orders before restart.
- A restart gate that requires explicit human authorization after a stop, material change, or unexplained state discrepancy.
If any condition is missing, keep the integration at read-only or simulation and close the gap first. If an account is already connected to a live agent and the owner cannot be identified, revoke or disable its write credentials through the exchange’s documented process, preserve evidence, and have an authorized human reconcile account state. Do not ask the agent to “clean up” an unknown position as a substitute for that review.
Why “who owns the agent?” is not a naming exercise
An owner field in a spreadsheet is useful only if it connects to decision rights. A person who cannot revoke credentials, suspend the workflow, contact the exchange administrator, or demand reconciliation is a contact, not an operational owner. Conversely, giving one operator broad unchecked permissions creates a different problem: the control plan depends on one individual and may bypass second-person review for consequential actions.
The distinction matters because an agent’s identity can drift while its label stays the same. The model, system prompt, tools, delegated sub-agents, exchange connection, runtime, risk limits, or account may change independently. KuppingerCole’s “When Software Becomes Staff” keynote describes this as a delegated-authority and identity-governance problem. Its accessible page provides a video description and transcript; the video playback itself requires membership, so this article uses the available transcript rather than claiming to have watched the recording. The keynote’s central operational questions are useful: what authority was delegated, what changed during execution, who can stop the mission, and where does evidence live? The article’s table and code below turn those questions into a local acceptance exercise; they are our proposed controls, not KuppingerCole’s test results.
The FCA’s 2025 review of algorithmic trading controls identified weaknesses in ownership, documentation, testing, and controls among the principal trading firms it reviewed. The FCA also states that the review creates no new rules. Treat it as observations from a specific review, not as evidence that every crypto agent has the same failure rate or that the review automatically applies to a retail user. Read the FCA’s scope and findings.
For firms and activities within its scope, MiFID II Article 17 requires investment firms engaged in algorithmic trading to have resilient systems, thresholds and limits, controls against erroneous orders, business continuity, testing, and monitoring. That provision is not a universal rule for every person using an AI tool to trade crypto. Whether a specific crypto asset, service, entity, or activity falls under a particular regime depends on jurisdiction and facts. The ESMA single-rulebook text is a source for the rule’s scope; it is not individualized legal advice. The FCA separately warns that some copy-trading arrangements involving financial instruments may amount to portfolio management, depending on the service and client intervention. These boundaries are reasons to obtain qualified advice before deploying an arrangement with customers or regulated instruments, not a shortcut to classifying an activity. ESMA Article 17 · FCA copy-trading guidance.
The operator-of-record card
Create one versioned record per agent mission. Keep it short enough to read during an incident and specific enough that a second operator can stop the process without guessing. The following fields are the minimum for this protocol:
| Field | Required answer | Evidence to retain |
|---|---|---|
| Mission ID | Unique, immutable ID for this deployment window | Registry entry and change history |
| Accountable owner | Named person plus role and contact route | Approval record; current on-call directory |
| Stop authority | Primary and substitute who can disable writes | Demonstrated access or tested procedure |
| Scope | Exchange, account, instruments, order types, maximum size and duration | Exchange configuration and approved mission record |
| Build identity | Model, system prompt, strategy code, tools, dependencies and delegated agents | Version IDs or hashes; release record |
| Credential boundary | Credential owner, permissions, expiry, storage and revocation method | Exchange/API permission snapshot; secret-manager reference, never the secret itself |
| Runtime guardrails | Order checks, rate limits, loss or exposure thresholds, duplicate protection | Versioned policy and test evidence |
| Event evidence | What is logged, where, retention, clock basis, and who can read it | Sample redacted event and access controls |
| Stop semantics | What “stop” blocks, cancels, preserves, and cannot undo | Exercise result, including partial-fill handling |
| Reconciliation owner | Human who compares exchange state and agent state | Signed or attributable reconciliation record |
| Restart authority | Human required to approve restart and conditions to satisfy | Restart checklist and recorded authorization |
| Expiry and review | End time, review triggers, and what happens when no one renews | Scheduled expiry and notification test |
Do not put API keys, seed phrases, passwords, or private keys in this card, an article, a ticket, or a log. Store only an opaque credential reference and the approved access path. OWASP’s LLM application guidance identifies risks such as excessive agency and insecure handling around tool-enabled systems; use it as a security checklist input, not proof that a trading integration is secure. OWASP Top 10 for LLM Applications.
Ownership should be decomposed rather than hidden behind one “AI owner” label. The business owner defines the purpose and acceptable outcome. The technical owner maintains the executable system, dependencies, and deployment. The credential custodian controls access to exchange permissions. The on-call operator can stop the mission. The reconciliation owner compares external account truth with internal records. The risk or compliance contact advises on applicable constraints. In a small organization one person may hold several roles, but the record should still name each responsibility and specify which decisions require a second person.
Twelve cases to run before live authority
Run each case in a tabletop session or a sandbox that cannot place real orders. The purpose is to discover whether people, permissions, logs, and procedures line up. For every case record: scenario, expected action, actual action, evidence, owner, time to contain, unresolved uncertainty, and remediation date. Do not report a simulated pass as a production test.
| # | Scenario | Required result | Evidence that counts as a pass |
|---|---|---|---|
| 1 | The original owner leaves the company during an active mission | The substitute takes ownership; the agent does not inherit broad authority by default | Updated owner record, access confirmation, and successful stop drill |
| 2 | The on-call operator is unavailable | A named substitute can reach the stop control and the exchange administrator | Directory path tested in the exercise; no credential sharing by chat |
| 3 | A model or prompt version changes without a mission review | The change is detected and live authority remains disabled until approval | Version mismatch alert and blocked restart record |
| 4 | A delegated sub-agent is added to the workflow | The parent mission records its identity, purpose, tools, and permission boundary | Registry diff and scope review |
| 5 | The agent attempts an instrument or order type outside the approved scope | The action is rejected before transmission | Denial event with mission ID and policy version |
| 6 | A request repeats after a timeout, although the first request may have reached the exchange | Duplicate protection prevents an unintended second order or routes the case to human reconciliation | Idempotency or duplicate check evidence; exchange state is consulted |
| 7 | The stop command arrives while an order is open | New order submission is blocked; cancellation is attempted where supported; fill uncertainty is surfaced | Timestamped stop event, cancellation result, and unresolved-order list |
| 8 | An order is partially filled before cancellation | The filled portion is treated as real account state; the agent does not claim it was undone | Exchange-confirmed fill and reconciliation entry |
| 9 | A provider, model, API permission, or exchange policy changes | The change triggers review or disables the mission until its effect is understood | Change ticket tied to the mission and a fresh authorization decision |
| 10 | The event log is delayed, incomplete, or unavailable | The system fails closed for new live actions or follows a documented, bounded degraded mode | Alert, defined degraded behavior, and evidence preservation |
| 11 | The agent produces a valid-looking but unexplained action | The operator can trace request, policy, tools, approval, exchange response, and state change | End-to-end event chain with clock and correlation IDs |
| 12 | The mission expires or its owner fails to renew it | Write authority ends; restart requires a new review | Expiry enforcement and a recorded renewal decision |
“Fail closed” is a recommendation for new live actions when the system cannot establish authority or state. It does not necessarily mean that a software process should terminate abruptly while leaving an exchange order unobserved. The safe response may be to block new orders, continue read-only status collection, alert a human, and preserve the open-order state. This is a design choice that must be tested against the actual exchange API and account configuration.
Scoring without inventing a maturity benchmark
Do not convert the twelve cases into a market benchmark or claim that a particular score predicts financial loss. This protocol has no validation sample and no statistical relationship to incident outcomes. Use it as a gap register. A team can classify each case as demonstrated, partly demonstrated, not demonstrated, or not applicable, with a short reason. “Not applicable” should identify the boundary that makes the scenario irrelevant; it should not mean “we have not checked.”
For decisions, give cases 1, 5, 7, 8, 10, and 12 veto weight: if operator continuity, scope enforcement, stop semantics, partial fills, monitoring loss, or expiry cannot be demonstrated, do not grant live write access. This weighting is a recommendation in this proposed checklist, not a result derived from statistical testing. The other cases still need owners and dates; they simply do not replace those safety-critical conditions.
Stop is a sequence, not a button label
A visible kill-switch can be misleading if it only stops the agent process while leaving valid API credentials, queued jobs, delegated work, or open orders active. Write the sequence down and identify the system that enforces every step:
- Mark the mission
STOPPINGin an authoritative control record and reject new work for its mission ID. - Disable the agent’s ability to submit new orders at the execution boundary. Prefer a separate policy gateway or exchange permission boundary over a prompt asking the model to stop.
- Revoke or disable write credentials using the exchange’s documented mechanism when the incident warrants it. Confirm whether existing sessions or signed requests remain valid.
- Enumerate pending, acknowledged, rejected, unknown, and partially filled requests using exchange-confirmed data. Do not infer an order’s state from a client timeout alone.
- Attempt cancellation only for open orders that the account and exchange permit the operator to cancel. Record each result; cancellation is not reversal of an already executed fill.
- Preserve relevant logs and snapshots. Restrict access and redact secrets, but do not destroy evidence as part of “cleanup.”
- Assign a human to reconcile balances, fills, fees, and open orders against the agent’s local state.
- Leave the mission stopped until the owner and restart authority approve a documented recovery plan.
The sequence depends on the exchange API, custody arrangement, and integration design. A cloud agent may continue to retry from a queue after its process is killed. A credential rotation may not revoke existing tokens immediately. An exchange outage may prevent cancellation. A stop routine must describe these failure modes and tell the operator what status is unknown rather than promising instantaneous containment.
A dependency-free Node.js completeness checker
The following example checks whether the operator card contains minimum fields and whether the mission has a future expiry. It is deliberately a completeness check, not a security control: it does not authenticate anyone, contact an exchange, inspect permissions, validate cryptographic hashes, or enforce a kill-switch. A production system must enforce those properties at its own trusted boundaries.
// node validate-mission.js mission.json
const fs = require('node:fs');
const file = process.argv[2];
if (!file) throw new Error('Usage: node validate-mission.js mission.json');
const mission = JSON.parse(fs.readFileSync(file, 'utf8'));
const required = [
'missionId', 'accountableOwner', 'stopAuthority', 'exchangeAccountRef',
'allowedInstruments', 'allowedOrderTypes', 'modelVersion', 'strategyVersion',
'credentialRef', 'credentialExpiry', 'stopProcedure', 'reconciliationOwner',
'restartAuthority', 'missionExpiry', 'evidenceLocation'
];
const missing = required.filter((key) => {
const value = mission[key];
return value === undefined || value === null ||
(typeof value === 'string' && value.trim() === '') ||
(Array.isArray(value) && value.length === 0);
});
const now = Date.now();
const expiry = Date.parse(mission.missionExpiry);
const credentialExpiry = Date.parse(mission.credentialExpiry);
if (!Number.isFinite(expiry) || expiry <= now) missing.push('missionExpiry must be a future ISO date');
if (!Number.isFinite(credentialExpiry) || credentialExpiry <= now) missing.push('credentialExpiry must be a future ISO date');
if (mission.withdrawalsEnabled === true) missing.push('withdrawalsEnabled must be false for this example policy');
if (missing.length) {
console.error(JSON.stringify({ ok: false, missing }, null, 2));
process.exitCode = 1;
} else {
console.log(JSON.stringify({ ok: true, missionId: mission.missionId }, null, 2));
}
The key withdrawalsEnabled is included as an illustrative local policy. Some exchanges do not expose an API-level switch with that exact name, and disabling withdrawals in an API key does not make an account risk-free. Map the example to documented controls available for the actual platform. If the platform cannot separate permissions to the degree the mission requires, do not pretend the JSON validator compensates for that limitation.
A useful test fixture includes a complete record, a record with no accountable owner, an expired mission, an expired credential, and a record that accidentally permits withdrawals. The expected outputs are deterministic, so teams can test the validator itself without market data. These are software fixtures, not evidence about agent performance or exchange security. Keep synthetic identifiers and fake references in shared examples; never put a real credential in a fixture.
Authorization should bind to the mission, not to a vague “AI approval”
An approval is meaningful only if the approver sees what they authorize. The approval record should show the account reference, scope, action category, limits, expiry, relevant version identifiers, and the consequences of the proposed action. A general approval such as “allow the AI trader to operate” cannot distinguish a read-only diagnostic from a live order or a withdrawal attempt.
If every individual order requires approval, measure whether the reviewer can actually assess the request and whether the process creates queue pressure. A rapid series of near-identical approvals can become a ritual. If decisions are delegated to a bounded policy, define the envelope in machine-enforceable conditions and route exceptions to a human. The FCA review discusses control ownership and testing in algorithmic trading firms; ESMA’s rule text calls for thresholds and limits where the rule applies. Those references support designing explicit boundaries, but they do not establish one universally correct order limit for crypto.
Separate the person authorizing the mission from the software that proposes an action. The event record should preserve the original principal, agent identity, mission ID, decision policy version, tool invocation, approval result, exchange response, and subsequent reconciliation. If a workflow delegates to another agent, preserve the parent-child relationship and the limits passed to the child. A log line saying “AI approved” does not answer whose authority was used.
Human oversight: resolve the conflict between speed and meaningful review
There is a real tension in governance guidance. Some operational work must stop immediately when an uncertainty crosses a threshold. Yet requiring a human to approve every low-impact step can create fatigue and superficial rubber-stamping. KuppingerCole’s transcript warns that “human in the loop” can be performative under time pressure and argues for enforceable control-plane capabilities. The FCA and ESMA materials emphasize controls and accountable oversight in the settings they cover. These views are not contradictory if approval is reserved for defined high-consequence exceptions while routine actions remain within bounded, observable, reversible policies.
Design the review interface around the decision, not around a wall of model text. Show the proposed action, source facts, uncertainty, policy rule, scope, maximum consequence, reversibility, and the control that will stop further actions. Give the operator a clear reject, pause, and escalation path. If the person cannot tell what will happen after approval, the approval is not sufficiently informed.
Do not use a model confidence score as a stand-alone authorization boundary unless it has been validated for the specific decision and failure costs. A low score may trigger review, but a high score does not prove that market data are current, the account is correct, the order is permitted, or the exchange received the prior request. Guardrails should rely on deterministic checks where possible: schema validation, allowlists, hard numeric limits, idempotency keys, stale-data checks, and independent exchange-state reconciliation.
Version changes are ownership events
Changing a model or prompt can alter behavior without changing the agent’s name. Changing an exchange API permission can alter consequences without changing the model at all. Treat material changes as a mission review trigger, and make the trigger explicit in the registry. The change list should include model provider and version, system prompt hash, strategy code version, tools and their permissions, memory or retrieval sources, sub-agent set, runtime image, policy version, exchange account, and risk limits.
This does not mean every patch must trigger the same governance ceremony. A documentation typo in an internal runbook is not equivalent to granting a new write permission. Classify changes by whether they alter authority, data exposure, decision logic, execution semantics, or the ability to stop and recover. A configuration change that expands instruments or removes a stop condition deserves a fresh review. A dependency update may require a test proportional to its effect. Record the rationale so the team can later distinguish “reviewed and accepted” from “never noticed.”
The owner should receive an alert when a mission’s original assumptions cease to hold. Examples include account migration, exchange terms or API behavior changes, vendor access changes, risk-limit changes, model retirement, key rotation, organizational transfer, and a missing log stream. When ownership changes, do not simply replace a name in a spreadsheet. Revoke the outgoing operator’s access, confirm the incoming operator’s stop authority, transfer evidence access, and run a handoff drill.
The minimum evidence chain for an incident
When someone asks what happened, the team should be able to reconstruct the chain without trusting the agent’s own narrative. Retain the initiating request, authenticated principal, mission version, pre-action state, policy decision, model and tool versions, every tool call, exchange request and response identifiers, status snapshots, approval record, stop events, and reconciliation result. Preserve timestamps with a stated clock source and enough correlation identifiers to join records across services.
Avoid logging secrets or unnecessary personal information. Use opaque references for credentials and controlled access to sensitive evidence. Define retention according to operational needs and legal obligations; do not copy customer records into an informal incident channel. OWASP’s LLM application material is a useful starting point for prompt injection, excessive agency, and sensitive-information handling, but it does not replace an exchange integration threat model.
Logs are not automatically truthful simply because they exist. Check whether an agent can modify its own audit records, whether administrators can edit them without trace, whether clocks drift, and whether a failed network call leaves a gap. Store security-relevant events in a location with access controls separate from the agent’s runtime. Red-team the evidence path with a scenario that intentionally drops a response or produces a timeout. A system that cannot distinguish “request rejected” from “request may have been accepted” must make that uncertainty visible and block blind retries.
A practical decision matrix
| Readiness state | Evidence | Decision |
|---|---|---|
| No named owner or substitute | No person can demonstrate authority to stop and reconcile | Do not connect write access; identify owner and backup |
| Owner exists but mission scope is vague | Instruments, order types, account, limits, or expiry are missing | Keep read-only; define a bounded mission |
| Scope is documented but stop behavior is untested | Cancellation, partial fills, credential revocation, or queue retries are unknown | Run sandbox/tabletop cases; no live order authority |
| Stop works but reconciliation is not assigned | No one compares exchange truth with local records | Assign reconciliation owner and demonstrate end-to-end evidence |
| Readiness controls demonstrated in exercise | Scope, identity, stop, evidence, reconciliation, expiry all pass | Consider a narrowly bounded next stage subject to legal, security, and investment review |
| Material incident or unexplained state mismatch | Control evidence incomplete or actual state uncertain | Stop new actions, preserve state, reconcile manually, then reauthorize |
The last readiness row is not a recommendation to trade. It only says the ownership and operational-control portion of the exercise has been demonstrated. A separate review must consider whether the use is lawful, contractually permitted, secure, financially appropriate, and supported by the relevant platform. These are independent gates.
A tabletop flow you can run in one meeting
Bring the operator, technical owner, credential custodian, and person responsible for reconciliation. One person reads each case, another states the action they would take, and a third locates the evidence. Do not let the person who built the integration answer all three roles by assumption. If the organization is very small and one person truly holds several roles, make that explicit and add an external or second-person review for decisions with material consequences.
Start with a read-only scenario. Ask the operator to identify the mission, account, owner, build version, and last event. Then introduce an ambiguous timeout: the agent transmitted an order request but did not receive a response. The operator must decide whether another request is safe. The correct operational response is to query the exchange or escalate to an authorized human, not blindly resend because the local call timed out. The precise implementation depends on exchange support for idempotency and status queries.
Next, simulate the stop while an order is pending and another has partially filled. Ask which component blocks additional orders, who can revoke credentials, where the exchange state is queried, who records the fill, and what is required before restart. If the team’s only answer is “kill the container,” continue the exercise: queued tasks, tokens, in-flight signed requests, and child agents may outlive that process. The goal is to find concrete dependencies, not to shame an operator for missing a control.
Finally, change one input at a time: model version, API scope, owner, exchange account, or risk policy. Ask whether the mission is re-approved or automatically held. Close the meeting with a list of failed cases, one owner per remediation, a due date, and a retest condition. A failed tabletop case is useful evidence of an unclosed gap; it is not evidence that the system has already caused a loss.
Mermaid: the stop-and-reconcile path
flowchart TD
A[Mission active] --> B{Scope, identity and telemetry valid?}
B -- No --> C[Block new live actions]
B -- Yes --> D[Agent proposes bounded action]
D --> E{Deterministic policy allows it?}
E -- No --> F[Record denial and notify owner]
E -- Yes --> G{Human approval required by mission?}
G -- Yes --> H[Show evidence and consequence]
H --> I{Authorized approval?}
I -- No --> F
I -- Yes --> J[Send through scoped execution boundary]
G -- No --> J
J --> K{Exchange response unambiguous?}
K -- Yes --> L[Record exchange state and reconcile]
K -- No --> M[Stop retries; query exchange state]
M --> N{State reconciled?}
N -- No --> O[Keep mission stopped; human investigation]
N -- Yes --> L
C --> P[Stop authority blocks writes and preserves evidence]
P --> O
This flow is a proposed operational pattern, not an exchange protocol. Teams should map each node to an actual component and test what happens when that component is unavailable. A diagram without an enforceable execution boundary is documentation, not a control.
Failure modes that a polished demo often hides
Owner by title, no authority. A director is listed as owner but cannot disable credentials or reach the exchange administrator. Fix the decision rights, not the label.
The vendor is treated as the accountable operator. A vendor can support infrastructure, but the deploying organization still needs to define who authorizes the mission, who understands the account, and who responds to an incident. Contracts and jurisdiction may allocate legal duties differently; do not infer them from a product dashboard.
A stop stops only one process. A worker terminates, but a queue, scheduler, child agent, or token continues. Inventory execution paths and test the stop at the point where external side effects are authorized.
Cancellation is confused with reversal. An open order may be cancellable; a completed fill is a real transaction. Record both states distinctly and make reconciliation explicit.
A timeout is treated as rejection. The exchange may have accepted a request even though the client did not receive the response. Query authoritative state before retrying.
Approval fatigue converts review into a click. Excessive low-value approval prompts can degrade attention. Use bounded deterministic rules for routine low-risk actions and human review for clearly defined exceptions; test the actual interface under realistic workload.
Model change inherits old approval. The mission’s approval referred to a prior build. Bind approval to versioned artifacts and require review when material components or permissions change.
Credential custody is undocumented. A team knows a key exists but cannot tell who can revoke it or whether it can withdraw funds. Map the exchange’s actual permission controls, not a generic product feature list.
Evidence is written by the same agent being investigated. The runtime can alter or omit its own logs. Separate collection and access controls, preserve exchange-side evidence, and test gaps.
Recovery is an automatic restart. A supervisor restarts a stopped agent before account state is reconciled. Require an explicit restart authority, documented reason, and fresh state comparison.
A sub-agent falls outside the parent mission. Delegation expands access or duration. Propagate scope and expiry to children, record parent-child identity, and block unregistered descendants.
“Read-only” is assumed rather than checked. The API key or integration may retain write permissions. Verify the exchange configuration and, where possible, prove attempted writes are rejected in a safe sandbox.
Contradictions and boundaries to keep visible
There is no single universal governance design for all agents. A read-only research assistant, a paper-trading simulator, a human-approved order workflow, and an autonomous execution service have different consequences and need proportionate controls. Applying the same burdens to every use can waste effort; treating a high-authority agent like a low-impact assistant can leave dangerous gaps. Gartner’s public guidance similarly argues for governance proportional to autonomy and scope, but analyst forecasts are not observed outcomes. The article’s own twelve cases are not a universal standard either; teams should adapt them and preserve the reason for each exclusion.
Human oversight is both necessary and limited. A human can bring context, judgment, and accountability, but a human cannot reliably inspect every low-level operation at machine speed. The design question is therefore where to put approvals, which actions must be blocked deterministically, what evidence the reviewer sees, and how the system escalates uncertainty. “Human in the loop” is not a property you can claim from a UI screenshot; it needs a defined decision and a credible opportunity to intervene.
A vendor’s “kill switch” can be valuable but does not by itself prove that credentials are revoked, exchange orders are cancelled, queues are drained, and state is reconciled. Conversely, a local kill-switch may stop execution but not control a request already accepted by a remote service. Document the boundary and uncertainty. The FCA review covers regulated principal trading firms in its sample; ESMA Article 17 applies to investment firms and algorithmic trading within the framework. Neither source should be generalized into a claim that every retail crypto activity has identical duties.
Backtesting remains useful for evaluating a historical hypothesis, but it cannot establish that the live owner, permissions, order lifecycle, observability, or incident response are ready. A successful tabletop is also limited: it tests a team’s ability to describe and demonstrate a procedure under exercise conditions, not whether the market strategy will perform or whether a real exchange will behave as expected. Keep these evidence types separate in dashboards and decisions.
Rollout sequence: authority only increases after evidence
Stage 0 — inventory. Identify every agent, workflow, exchange connection, account, credential reference, owner, and downstream process. Search code, scheduled jobs, cloud secret stores, and integration dashboards. Unregistered automation should not receive new permissions while inventory is incomplete.
Stage 1 — read-only. Allow data retrieval and reporting only. Confirm the agent cannot submit orders using its current credentials. Test the denied action in a safe environment and inspect exchange-side permission settings. A statement in a prompt is not a substitute for permission enforcement.
Stage 2 — paper or sandbox. Exercise the twelve scenarios with fake or sandbox state. Include timeouts, duplicate delivery, partial fills, missing logs, owner departure, expiry, and model changes. Record whether results are deterministic and whether the operator can find evidence.
Stage 3 — bounded approval. If legally and contractually appropriate, test an environment where a human explicitly approves each defined consequential action. Make sure the approval contains enough context and is tied to the mission version. Watch for fatigue and queue pressure; if reviewers cannot make informed decisions, the process should not be called a meaningful approval gate.
Stage 4 — narrowly scoped live authority. This is a separate business, legal, security, and investment decision. Keep the scope small, time-bound, reversible where possible, observable, and easy to revoke. Use a small exposure only if qualified decision-makers decide that is appropriate; this article does not prescribe an amount or recommend that anyone trade.
Stage 5 — review and renewal. Re-run cases after material changes, incidents, owner turnover, permission changes, exchange migration, or missed telemetry. Expire missions unless explicitly renewed. A dormant agent with active credentials is still an operational exposure.
Checklist before connecting or renewing an agent
- [ ] Mission ID, owner, backup, and stop authority are named.
- [ ] The owner and backup have demonstrated the stop and credential-revocation path.
- [ ] Exchange account, instruments, order types, limits, and mission expiry are explicit.
- [ ] Model, prompt, strategy, tools, policies, and delegated agents are versioned.
- [ ] Credential permissions have been checked in the exchange interface or API configuration.
- [ ] Withdrawals and transfers are disabled if the platform provides a suitable control and the mission does not need them.
- [ ] A timeout cannot cause blind duplicate submission.
- [ ] Stop behavior covers queued tasks, child agents, pending orders, partial fills, and unknown responses.
- [ ] Evidence can be joined from request through exchange response and reconciliation.
- [ ] A human owns post-stop reconciliation; a different human or defined authority owns restart where appropriate.
- [ ] Case results, failures, remediation owners, and retest dates are recorded.
- [ ] Legal, security, contractual, and financial reviews have been done for the actual jurisdiction and use.
- [ ] The team can explain what it does not know and what will remain stopped until that uncertainty is resolved.
Limits and source notes
This checklist was authored on 18 November 2026 as an original operational proposal. The twelve scenarios are a synthetic sample chosen to cover ownership, identity drift, scope, duplicate requests, stops, partial fills, changes, telemetry loss, evidence, and expiry. No agent, exchange, customer, trading strategy, or live system was tested. The Node.js snippet validates only document completeness and date fields. It does not determine whether a control is implemented, safe, lawful, or effective. No performance, loss probability, adoption rate, or regulatory conclusion is inferred from the exercise.
The FCA source reports observations from its multi-firm review and explicitly says it does not create new requirements. ESMA Article 17 is scoped to investment firms and algorithmic trading within MiFID II. FCA copy-trading guidance concerns arrangements that may amount to portfolio management for financial instruments in specified circumstances. KuppingerCole’s page contains an accessible summary and transcript, while video playback requires membership; only the transcript and page description informed this article. OWASP provides general LLM application security guidance, not crypto exchange certification. The OpenAI Community discussion below is an individual product-support question, not evidence of prevalence or a general policy rule.
One real user discussion asks how to transfer ownership of a workspace agent when its creator leaves, including what happens to maintenance and continuity. It illustrates a concrete handoff question, not a statistically representative user need. Read the discussion. The GSC signal motivating this article was also weak: one impression for a query about who should own an AI agent in an organization, at an average position near 10 in the sampled period. That is a discovery hint only, not proof of demand or a ranking promise.
For a separate baseline on distinguishing crypto AI backtests from live evidence, see the Trustly AI quantitative testing guide linked near the beginning of this article. For the limits and requirements stated in the official materials, read the linked FCA and ESMA pages directly and obtain qualified advice for the actual activity. Do not treat this article as investment advice or as permission to connect an autonomous agent to a live account.
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.