Odingard Security

AI agents can now spend money, deploy code and send email on their own. Guardian lets them do the everyday work alone, and makes them ask you first when it matters. Free to start → odingard.com/guardian

AI agents can now work on their own, all day, with nobody watching. That’s great until one does something you didn’t want. Spends money. Deletes something. Pushes a change live. Guardian fixes that. Your agent handles the everyday stuff on its own. When it’s about to do something that matters, it stops and asks you first. You tap yes or no. And you always have proof of who said yes. If you’re building agents that do real work, DM me

Agents are getting wallets. Nobody’s asking who approved the purchase. Guardian sits between the agent and the money: everyday actions run, big ones wait for a person, and every decision comes with a signed receipt the merchant can verify before shipping. Building agent commerce or wallets? DM me. Looking for design partners.

audience): “Are you really okay with models deciding what actions to take?” — @JoshARosen State machines govern how an agent works. Something also has to govern whether a consequential action is allowed to happen. That’s the layer Guardian adds:
→ Deterministic ALLOW / ASK / DENY before any action runs
→ No model in the decision path
→ Humans approve the exact action, not a summary
→ Every transition leaves verifiable evidence Works alongside LangGraph, Mastra, XState or your own loop: guardian.odingard.com

You authorize your AI agent to spend $8,450. It attempts a different transaction for $18,450. Should having the payment credentials be enough? Absolutely not. Guardian binds authority to the exact action and requires fresh authorization when the transaction changes. This isn’t about giving AI agents more access. It’s about making sure they can only exercise the authority humans actually gave them. Watch Guardian enforce it. Stripe sandbox demonstration. No real money moved. odingard.com/guardian

AI agents are moving from answering questions to taking real actions. Spending money. Deploying infrastructure. Accessing sensitive systems. Delegating work to other agents. But there’s a fundamental problem: Having access doesn’t mean having authority. We built Guardian to solve that. Human Authority Infrastructure for Autonomous AI. Guardian establishes who has authority, governs how it’s delegated, enforces boundaries at execution, and produces cryptographically verifiable evidence of what happened. The agent is never the authority. The human is. This is Guardian. odingard.com/guardian Open-source SDK: github.com/Odingard/guardian…

The gap I keep coming back to is that agent identity and agent authority are fundamentally different problems. An agent can have a valid identity, legitimate credentials, and permission to access a system without having human authority to cause a particular consequence. That distinction becomes critical when agents can delegate work, move money, deploy infrastructure, or interact across organizational boundaries. I think the missing infrastructure is an enforceable chain connecting the human principal, delegated authority, exact action, execution boundary, and verified outcome. And it cannot be an optional authorization check inside the agent. If the agent still controls an unrestricted credential or execution path, the boundary can be bypassed. That’s the architectural problem we’re tackling with Guardian. I’m curious whether you see this emerging as an extension of traditional IAM or as an independent infrastructure category for autonomous systems. @atShruti insights.array.vc/p/agents-b…

Guardian isn’t an email guardrail. It’s human authority infrastructure for autonomous agents. Email is just one example. The same authority layer can govern an agent that wants to: • send or delete messages • make purchases or subscriptions • move money • call APIs or MCP tools • change cloud infrastructure • modify code or production systems • share sensitive data • delegate work to another agent • eventually control physical systems The pattern stays the same: Agent proposes an action → Guardian determines ALLOW / ASK / DENY → exact authority is bound to that action → execution happens → the result is verified and receipted. Guardian MCP is now live with 3 governed tools and a 99/100 trust score on MCPRush. If you’re building agents, MCP infrastructure, gateways, wallets, browsers, or execution platforms, I’d like to test where Guardian fits in your stack. @OpenAIDevs @vercel @composio @claudeai @mcprush github.com/Odingard/guardian…

A useful question came up today: What happens if an AI agent gets approval, then changes the action afterward? Example: You approve: “Send $90 to Vendor A.” The agent then tries: “Send $190 to Vendor B.” Guardian does not treat that as the same approval. The approval is bound to the exact action that was reviewed. Change the recipient, amount, resource, environment, or another protected field and Guardian evaluates it again. That means a human approval can’t quietly become broader authority after the fact. This is the difference between: “the user approved something” and “the user authorized this exact consequence.” #AI #AI_Agents

Guardian is live. AI agents can send email, spend money, call APIs and operate software. But access is not authority. Guardian puts human authority between the agent and the consequence. ALLOW / ASK / DENY. Try it: github.com/Odingard/guardian… ⭐ the repo if you believe autonomous agents need an independent authority layer.

Your agent's output should be a proposal, not an action. Guardian is the human authority layer for autonomous AI — every tool call gets an ALLOW / ASK / DENY before anything executes. Zero model calls in the decision path, 1,000+ tests behind it, signed evidence of every decision. Open-source SDK (Apache-2.0): npm i @odingard/guardian-sdk github.com/Odingard/guardian…

AI agents are getting smarter, more capable, and more autonomous. That isn’t the problem. The problem is deciding who has authority when the agent can actually do things. GUARDIAN is the human authority layer for autonomous AI. Intelligence can belong to the agent. Capability can belong to the agent. Execution can belong to the agent. Authority belongs to the human. Guardian is built to preserve that authority across intent, delegation, memory, protected data, tools, transactions, runtime trust, execution and proof. The real architectural test: If a completely new kind of agent appears tomorrow, can Guardian govern it without changing the authority kernel? It must. Because the future isn’t one assistant. It’s thousands of agents acting across every part of our lives. One human. Many agents. One authority layer. Open-source SDK (Apache-2.0): github.com/Odingard/guardian…

Soon a billion people will hand agents their lives. The problem isn’t that AI can act. It’s that access quietly becomes authority #OdingardSecurity #Guardian

Everyone wants 20 AI agents working for them. Almost no one is ready for what happens when those agents start acting on their own. Guardian is the authority layer that keeps them from becoming you. #AIAgents #AIOversight #AgenticAI #AISecurity @AnthropicAI