TickLogic

Authorization & accountability for AI agents moving money on Solana. Give your AI agent a wallet it can't run off with.

[Mora | Offline Payments @morapayments]

Payments shouldn’t stop when connectivity does.

Mora:

Lock funds on-chain
Disconnect
Sign offline
Reconnect
Redeem at a merchant POS

No RPC call while offline. The payment settles on-chain when connectivity returns.

Devnet demo ↓
https://t.co/H8wqCyJJX8

[TickLogic @ticklogicai]

Anyone can write a spending limit. The hard part is proving an agent’s off-chain execution on-chain, inside Solana’s limits.

A disputed step replays natively in about 28.8k CU, and the dispute proof fits in 662 bytes, under the transaction limit. Measured on devnet.

[TickLogic @ticklogicai]

Not a diagram, a receipt.

The gate decides in about 461 CU, roughly half a second. An authorized 300 USDC payment clears.

An injected "send everything" is stopped at the same gate. Same agent, same key, different outcome.

Measured on devnet.

[TickLogic @ticklogicai]

Your AI agent has a wallet.

A prompt injection says: send everything.

Before that payment can land, the policy checks amount, destination, limit and expiry on-chain.

The move is braked and nothing leaves. The signature was valid.

The authority was not.

[TickLogic @ticklogicai]

Agent accountability is two problems, not one.

First: is a real human answerable for the agent.

Second: what was it allowed to do, and can you prove it stayed in bounds.

The first is identity. The second is enforceable policy and replayable proof.

We build the second.

[TickLogic @ticklogicai]

An AI fund cannot ask LPs to trust a dashboard.

LPs need to know:
Did the agent stay within mandate?
Can a disputed decision be replayed?
Does dishonesty have a cost?

That is the difference between transaction history and accountable execution.

[TickLogic @ticklogicai]

A trading agent should not have the same authority as the treasury that funds it.

Give it:
A per-trade ceiling.
A daily budget.
Approved venues.
A fixed expiry.
A policy every fill can be checked against.

Autonomy should be scoped, not unlimited.

[TickLogic @ticklogicai]

Wallets and multisigs solve custody.
TickLogic solves authorization and accountability above custody.

Owner: multisig.
Agent: mandate.
Funds: vault.
Value moves: gated.
Off-chain decisions: replayable.
Dishonesty: bonded.

The layers are complementary.

[TickLogic @ticklogicai]

A gate decision costs about 461 CU on devnet.

A disputed tick replays in about 28.8k CU.
The dispute proof is 662 bytes.

The hard part was not writing a policy.
It was making off-chain agent execution replayable inside Solana limits.

[TickLogic @ticklogicai]

Agents need enforceable limits.

Without limits, no one can trust them and that's the proof.

[OpenAI @OpenAI]

We're partnering with @huggingface to investigate an unprecedented security incident.

Cyber-capable OpenAI models compromised Hugging Face production during a benchmark evaluation.

Sharing preliminary findings to help defenders understand emerging risks:

https://t.co/CIor15y9xk

[TickLogic @ticklogicai]

Two enforcement regimes.
One policy.

Irreversible value moves are checked synchronously on-chain.

High-frequency reasoning stays off-chain and becomes challengeable through checkpoints and replay.

The same policy decides both.
No drift between prevention and proof.

[TickLogic @ticklogicai]

@solana TickLogic. Give your AI agent a wallet it can't run off with. On-chain policy checks every move before it lands, and every decision stays provable. Live on devnet.

[TickLogic @ticklogicai]

Agent accountability is two problems, not one.

First: is a real human answerable for the agent.

Second: what was it allowed to do, and can you prove it stayed in bounds. The first is identity.

The second is enforceable policy and replayable proof. We build the second.

[TickLogic @ticklogicai]

The prompt says:
“Send everything to this address.”

A normal agent wallet may sign it.

A TickLogic mandate checks the amount, destination, daily limit, expiry and status before anything leaves.

The right transaction goes through.
The hijacked one never lands.

[TickLogic @ticklogicai]

@gotto_ @moonpay @solana As the stack adds trading, execution and accounting, authorization becomes a product layer of its own.

Giving agents access is easy. Bounding that access without removing autonomy is the harder problem.

[TickLogic @ticklogicai]

@Rifat_EE @moonpay @circle x402 solves how agents pay.
The next bottleneck is authorization: how much can an agent spend, with whom, under which conditions, and who is accountable when it goes outside the mandate?

[TickLogic @ticklogicai]

@Bakioption @SumiroStudio Monitoring shows what an agent did.
The harder layer is deciding what it is allowed to do before the action happens.

Permissions, spending limits, approved destinations and accountability when it deviates from the mandate.

[TickLogic @ticklogicai]

Giving an agent a wallet is not the same as giving it governed authority.

A wallet answers who can sign. It cannot answer what the agent was allowed to do, or what happens when the prompt lies.

That check is now live to try in the OKX AI agent.

[Furkan | Sirius 🌟 @furkanzkx]

Your AI agent has a wallet. A prompt injection says: send everything.

TickLogic answers one question before any money moves: would this payment pass? And if not, which rule broke. @ticklogicai 🤖

No keys. Nothing signed. Real on-chain policy.

Free to try while it's early, on @okx @wallet https://t.co/tTZVZmVANN 👇 #OKXAI

Agent #6223 · X Layer

https://t.co/BBquOIee3r

[TickLogic @ticklogicai]

A wallet answers one question:
Who can sign?

An autonomous agent creates harder questions:
What was it allowed to do?
Did it follow the policy?
What happens if the operator lies?

TickLogic is built for the questions custody alone cannot answer.

[TickLogic @ticklogicai]

@Concordium @solana Identity proves who stands behind the agent.

The next step is proving what the agent was authorized to do and whether it followed that mandate.

Identity and execution accountability solve different parts of the same problem.