Palisec (@palisecagents) header
Palisec (@palisecagents) profile picture

Native agents. Open agent networks. Deterministic security for on-chain execution. $PALISEC: 0x1b4d04c8a67bf98bdf791ef928482bcb225d71ab

Joined November 2026
Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)Photo by Palisec (@palisecagents)
Palisec is live on Robinhood Chain mainnet. And instead of just saying it, here's the first receipt. An agent proposed a small transfer. Before anything moved, it asked Palisec. Palisec checked the policy (allowlisted recipient, value limit, budget) and returned ALLOW. The agent's key alone can't move funds. The smart account is a Safe that needs two signatures, so Palisec co-signed, for that exact operation only, and only until the authorization expired. It went through ERC-4337, EntryPoint v0.7, executed by the Safe 4337 module, and confirmed on chain. Gas cost: under one cent. If Palisec had said no, there would be no co-signature, and nothing would have reached the chain. This is the first flow. Over the next days we're verifying the rest on mainnet, each with its own receipt: an operation held for a human approver, an off-policy one blocked, and the budget, cooldown and emergency-stop limits. Mainnet uses real funds. Start with small balances. Check it yourself: robinhoodchain.blockscout.co…
31
3
36
822
$PALISEC utility. Work has started. The rule we set ourselves: the token should be used, not just held. So every utility is tied to the product being used. 01 · Pay for usage (in development) Palisec stays free on mainnet up to a monthly limit. Above it, teams buy decision credits with USDC, ETH or $PALISEC. Paying in $PALISEC gets a discount, and the tokens spent are burned in the same transaction. 02 · Hold for Pro (in development) An owner wallet holding a set amount of $PALISEC unlocks Pro: more agents and policies, longer audit history, higher limits, more Palisec Agent requests. Nothing is locked or sent. It's read from your wallet balance. 03 · Stake templates (planned, later) Stake $PALISEC to publish ready-made policies to a shared library. Templates that break or get reported lose part of the stake. This comes once more teams are building on Palisec. What won't change: core security stays free and never needs the token. No revenue share, no yield. Burns will be public, with a tx link for each. The payment contract gets audited before launch. Limits, discount and Pro threshold come when it ships. With receipts, like mainnet.
4
3
1
10
128
Every flow, on mainnet. Six outcomes, all recorded. Allowed → co-signed → executed Held for a human → approved → executed Off-policy → denied, PS_TARGET_001 Repeated intent → denied, PS_LOOP_001 Over budget → denied, PS_BUDGET_001 Emergency stop → denied, PS_PAUSED_001. Lifted → executed The smart account's history on Robinhood Chain shows exactly three operations: the three that were allowed. The denied ones never reached the chain, because Palisec never co-signed them. Check the receipts: robinhoodchain.blockscout.co… robinhoodchain.blockscout.co…
1
2
4
116
You asked for proof. Here's the first one, step by step. 1. Agent proposes 0.000001 ETH to an allowlisted address. 2. Palisec evaluates the policy: recipient, value limit, budget. ALLOW. 3. The Safe needs two signatures. The agent's alone is useless. Palisec co-signs this exact payload only, valid until the authorization expires. 4. A bundler submits the UserOperation to EntryPoint v0.7. The Safe 4337 module executes it. Success. 5. Gas, paid by the smart account: under one cent. If the answer had been no, there'd be nothing to show. No co-signature means no transaction. Next receipts: held for a human, blocked off-policy, budget and cooldown limits, emergency stop. robinhoodchain.blockscout.co…
13
2
16
314
The dual engine doesn't. Rust (WASM) and the TypeScript reference must agree on every field, or the request is denied. Parity is tested on every change with fixtures for every reason code and 6,000 random cases. That guards the code, not the rules. The rules are guarded differently: Nothing is allowed until it's allowlisted. Value, budget and cooldown caps limit any mistake. Large operations wait for a human signature. Policies are tested before activation, and every version is immutable. Missing data denies. One switch stops the whole organization. On-chain, the smart account moves only with PALISEC's co-signature on an allowed operation. Correct to the rules, and the rules kept small enough that a bad one stays contained. palisec.tech/security
6
7
358
Our DMs are open. Feel free to reach out.
8
1
7
517
npm install @palisec/sdk pip install palisec Palisec SDKs are now on the public registries. Before your agent sends a transaction, it asks Palisec. Palisec checks your rules (spend limits, allowed contracts, approval thresholds) and answers: allowed, held for a human, or blocked. Your agent sends only on ALLOW. Built-in tools for OpenAI Agents SDK, Vercel AI SDK, LangGraph and MCP, so it fits into the framework you already use. The policy evaluator also runs locally via @palisec/sdk/policy. palisec.tech/docs
6
2
7
298
Anyone can say their agent infrastructure works. We'd rather show you. Right now, Palisec is running its final verification on Robinhood Chain mainnet, with real transactions, through the full path: an agent proposes, Palisec decides, the smart account executes only what was allowed. Every flow gets tested for real. A small transfer within policy should be signed and land on chain. A transfer above the approval threshold should stop and wait, and only move after a human approves it. A transfer to an address that isn't allowlisted should be blocked and never reach the chain at all. And the limits have to hold under pressure: the hourly budget, the cooldown on repeated intents, and the emergency stop that freezes everything at once. When verification is complete, we won't just announce it. We'll publish the transaction hashes, so anyone can open the explorer and check each one themselves. Including the transactions that were blocked and never happened. Receipts, not promises. palisec.tech
21
26
617
Most status pages are green until someone complains. Ours isn't green unless it has just checked. Every time you open palisec.tech/status, it runs a live health check across the authorization API, the policy engine, sign-in and smart-account execution. If a check fails, it says "Not running" and tells you why. If it can't reach the check, it says "Unknown" and assumes nothing. If something is only configured, not tested, it says that too. A security layer that fails closed should report its own state the same way. palisec.tech/status
10
13
256
"Is there a real product?" Fair question. Don't take our word for it. Test it. Go to palisec.tech and scroll to the demo. No wallet, no sign-up. Pick a transaction an AI agent wants to send, and press Evaluate. Palisec runs the same policy evaluator that sits behind the API, check by check: → Is the target contract allowlisted? → Is this function allowed? → Is the value within the per-transaction limit? → Is the fee bounded? → Is the price data fresh? → Does it fit the rolling hourly budget? → Is the same intent being repeated too fast? → Is it above the human approval threshold? Then it decides: allowed, held for a human, or blocked. Now try to break it. Switch on an emergency stop. Take the fee estimator down. Cut the price feed. Palisec doesn't guess. When anything is uncertain, it blocks. That's the whole idea: an agent can propose anything, but nothing moves unless the rules say yes. palisec.tech
2
127
Palisec wasn't built overnight. Oct 21 · policy schema + deterministic evaluator Oct 29 · wallet sign-in, audit log Nov 4 · authorization API Nov 9 · Rust engine, SDKs Nov 16 · Agent, MCP, webhooks Nov 17 · on-chain enforcement Nov 18 · mainnet support Every step is public. palisec.tech/changelog
2
3
163
A security boundary is only as reliable as the environment in which it operates. Moving infrastructure to a production network is not a change of RPC endpoint and contract configuration. It is a reassessment of the assumptions the system depends on. Authorization decisions must remain deterministic. Signing permissions must retain their intended scope. Execution paths must enforce the same constraints, while deployment configuration, network identity and operational controls must remain consistent. A system that behaves correctly in staging has demonstrated functionality. It has not automatically demonstrated production integrity. At Palisec, we believe deployment should be treated as a continuation of security engineering, not the final step of software delivery. The standard is not whether the system deploys. It is whether its security guarantees survive the deployment.
2
4
196
PALISEC / DEPLOYMENT READINESS Before production execution, these are the validation priorities: → Decision consistency — Rust/WASM and TypeScript policy evaluators must reach the same authorization result. A mismatch must fail closed. → Execution enforcement — Safe and ERC-4337 transaction paths must preserve the intended policy boundary through actual on-chain execution. → Approval integrity — EIP-712 human approvals must remain bound to the exact transaction payload, policy version and expiry. → Replay and idempotency — Repeated submissions must not create duplicate or unintended operations. → Emergency controls — Pause, revoke and rotation paths must behave predictably when normal execution needs to stop. These are not independent checklist items. They form one security guarantee: an autonomous agent should never gain more execution authority than the system can verify and enforce.
2
177
One area receiving particular attention during Palisec’s deployment preparation is smart-account execution verification. Supporting ERC-4337 is not simply a matter of submitting a UserOperation and receiving a successful response from a bundler. The full execution path needs to be validated: • The account configuration and module permissions must match the intended authorization model. • The bundler and EntryPoint interactions must behave as expected. • The resulting on-chain execution must be verified, not inferred from submission success. • The enforcement boundary must remain intact throughout the process. This is where testnet demonstrations and production readiness begin to differ. A transaction being accepted for processing is not proof that it executed under the intended security constraints. For infrastructure securing autonomous agents, that distinction is fundamental. Authorization must hold through execution, not just at the point of decision.
2
1
214
The focus is shifting from demonstrating functionality to validating the conditions it must withstand in production. Network configuration, execution-path verification and operational reliability are receiving closer attention. The objective remains unchanged: every execution must be verifiably within its authorized boundaries.
7
7
248
An agent completing a task does not, by itself, establish that the execution was safe. In autonomous systems, successful outcomes are often treated as the primary measure of reliability. But the outcome tells only part of the story. It does not establish whether each action stayed within its permitted scope, respected spending and execution limits, followed the applicable policy, or produced an auditable record. This distinction becomes critical when agents operate across wallets, APIs, smart accounts and external services. A workflow can reach its intended result while still exceeding its authority along the way. Without verifiable execution controls and traceable decisions, success can conceal violations that only become visible after the fact. Infrastructure must therefore account for the entire execution path, not just the final result. A successful outcome is not proof of an authorized execution.
2
180
Two evaluators. One authorization decision. Palisec evaluates policy through two independent implementations: a Rust policy engine compiled to WASM and a TypeScript reference evaluator. The important part is not simply having two implementations. It is requiring them to agree. If their decisions diverge, the operation fails closed with PS_STATE_001. Execution does not proceed on the assumption that one evaluator must be correct. In autonomous-agent infrastructure, a policy decision is part of the security boundary. A discrepancy between implementations cannot be treated as a harmless software inconsistency. The engineering principle is straightforward: when authorization cannot be established consistently, execution must stop.
7
8
469
Making a product public is one milestone. Making the infrastructure dependable under production conditions is a different piece of work. The engineering focus at Palisec is now on the details that become increasingly important as we move beyond a testnet environment: how authorization decisions behave across different execution paths, how state remains consistent under concurrent operations, how failures are handled, and whether the system denies execution when its assumptions cannot be verified. These are not details that make for impressive launch announcements. They are the conditions that determine whether security infrastructure can be trusted in practice. We’re treating this stage as an engineering exercise, not a deployment ceremony. The objective is not simply to get the system running on another network, but to make sure its guarantees hold when the environment becomes less forgiving.
8
8
374
Demo walkthrough is live AI agents can move money. PALISEC checks every transaction they propose before it's signed. Within policy → signed Above threshold → held for a human Off-policy → never sent Free on Robinhood Chain Testnet. palisec.tech 0x1b4d04c8a67bf98bdf791ef928482bcb225d71ab
17
3
3
28
1,530
Dex has been updated
8
9
381