we've spent years stuck in crypto algo bubbles, optimizing for the most niche, risk on users and only showing up in other countries when a conference is in town payments and tokenization require widescale adoption across everyday use cases for crypto native infra companies, winning here means building deep trust with traditional businesses: proven engineering, security architecture, tight SLAs when something goes wrong, compliance failsafes, real account service the era of hardcore enterprise sales GTM is here and the companies that build it into their culture will win

What NEAR shipped this month: ✦ NEAR Intents crossed $19B+ in all-time volume and 25M+ total swaps. ✦ Confidential Payments went live on with Universal Send. ✦ $VVV is live on NEAR Intents and ✦ Illia Polosukhin (@ilblackdragon) and Arthur Hayes (@CryptoHayes) discussed the Privacy Renaissance on @therollup. ✦ NEAR AI and the Government of Bermuda partnered to deploy AI-powered public services. ✦ NEAR Intents began powering cross-chain swaps in Ledger Wallet. ✦ IronClaw released version v0.28 “IronClaw Reborn”. ✦ NEAR Intents integrated private USDC payments for the NEAR AI Agent Market. ✦ NEAR Intents
 joined the strkBTC Federation. ✦ NEAR AI shipped automatic PII anonymization. ✦ NEAR introduced Dynamic Resharding. ✦ NEAR AI and FailSafe launched AttackBench. ✦ NEAR hosted events at Consensus Miami and the SALT Digital Finance Forum in Bermuda. ✦ referrals went live ✦ The Bitwise NEAR Staking ETP drew roughly $3M in inflows ✦ Trezu (@trezuapp) launched confidential treasuries And much more.

# Cursor Features and Practical Usage 🪝 Want to bake "auto-format on edit" or "block dangerous commands" into the agent's behavior? Cursor Hooks let you intervene at each stage of the agent loop. 🏷️ Title: Agent Loop Interception (JSON) 🔗 URL: 📘 Overview Hooks are processes spawned to observe, control, and extend the agent loop. They communicate over stdio using JSON in both directions and run before or after defined stages of the loop. Use them for formatting, audit logging, secret scanning, and gating risky operations. ⚙️ How It Works Configure hooks in `hooks.json`, with priority Enterprise → Team → project (`/.cursor/hooks.json`) → user (`~/.cursor/hooks.json`). Key events include: ・`beforeShellExecution` / `afterShellExecution`: gate shell commands and post-process ・`beforeReadFile` / `afterFileEdit`: around file reads and edits ・`beforeMCPExecution`, `beforeSubmitPrompt`, `sessionStart`, `stop`, and more Each hook receives JSON on stdin (`conversation_id`, `model`, `hook_event_name`, etc.) and returns JSON on stdout. Control hooks return `{"permission":"allow"|"deny"|"ask"}`, and on `deny` you can attach `user_message` / `agent_message`. Exit code 0 means success, 2 blocks the action (equivalent to deny), and other codes fail open (unless `failClosed: true`). 🛠️ Practical Usage Auto-format after edits with `afterFileEdit`: read the JSON from stdin, pull `.file_path` with `jq`, run `prettier --write` on it, and exit 0. Block dangerous SQL or destructive commands with `beforeShellExecution`: inspect the command string and, if it matches, return `echo '{"permission":"deny","user_message":"This SQL is not allowed"}'`. For PII or secret scanning, register a `beforeReadFile` hook with `"failClosed": true` so that if the scan fails, content is never passed to the model and you fail safe. 💡 Use Cases Enforce formatting, linting, and commit conventions across the whole team. Gate production DB writes or `rm -rf`-style commands. Keep fire-and-forget audit logs via `sessionEnd` or `postToolUse`. Use a `matcher` to filter by tool type or command pattern so the hook runs only when needed. ⚠️ Caveats Mind the working directory: project hooks run from the project root, user hooks from `~/.cursor/`, and wrong paths fail silently. The default is fail-open, so always add `failClosed: true` to security-critical hooks. Invalid output JSON causes the hook itself to fail. Cursor auto-reloads `hooks.json`, but restart if changes do not take effect. Cloud agents support command-type hooks only; `sessionStart`, `beforeMCPExecution`, Tab hooks, and prompt-type hooks are not available there. #Cursor# #DevSecOps#

Practices for Integrating AI Agents into Enterprise Systems 【MCP Gateway / Tool Federation】 💡 Catchy Message "5 agents x 10 SaaS products = 50 custom integrations. This multiplication nightmare is what the MCP Gateway eliminates." Every new agent and every new SaaS connection compounds integration cost. Tool definition sprawl, schema inconsistencies, and silent API breaking changes -- these problems demand an architectural solution. 🔥 Problems Solved - N (agents) x M (SaaS) integration cost explosion - Duplicate and inconsistent tool definitions across agents - Indirect prompt injection through tool I/O - Tool selection accuracy degradation when too many tools are exposed to an agent - Silent SaaS API changes (schema drift) causing agents to process incorrect data 🏗️ The Pattern Bundle each SaaS connector as an MCP (Model Context Protocol) server behind a gateway that manages tool discovery, authorization, call auditing, and scope control. Dynamically filter tool allow-lists by principal (department x agent type), exposing only the minimum necessary tools to each agent. Dangerous tools (delete, transfer funds, external send -- irreversible operations) get approval hooks. Tool definitions and API schemas are versioned as "contracts," periodically validated against live APIs to detect drift. Backward-incompatible drift triggers alerts and automatic tool deactivation as a fail-safe. ✅ When to Adopt - Use when: 10+ SaaS integrations. Multiple agents share common tools. Struggling with N x M integration complexity. - Skip when: Single-purpose agent with 2-3 fixed tools (direct integration is simpler and more robust). APIs are stable with extremely low change frequency. ⚠️ Pitfalls - Exposing 20-30+ tools to a single agent degrades tool selection accuracy. Use tool RAG for dynamic filtering or split into role-specific sub-agents. - Without contract testing (drift detection), you won't notice SaaS API changes until agents silently process incorrect data. Salesforce field changes happen more often than you think. - Deferring MCP server authorization design leaves all agents with access to all tools -- an open invitation for misuse. 🛠️ Implementation Approach - Build MCP servers for each SaaS (Salesforce, ServiceNow, Jira, Slack, Box, etc.). Adopt official MCP servers where available; otherwise auto-generate tools from OpenAPI specs and wrap them as custom MCP servers. - Deploy an MCP gateway with a tool registry (catalog). Index all tools from each MCP server and configure allow-lists filtered dynamically by department x agent type. - Set up OAuth 2.1-based authorization with approval hooks. Attach approval gates (linked to P09 dynamic authorization PDP) to dangerous tools (delete, fund transfer, external send) so they never execute without human approval. - Build a drift detection pipeline using contract testing (Pact, etc.) and a schema registry. Run weekly reconciliation between tool definitions and live API schemas; auto-deactivate tools and alert on backward-incompatible changes. - Control per-agent tool exposure to under 20 using tool RAG or role-specific sub-agent splitting. Dynamically filter tools by intent to maintain selection accuracy. #AIAgents# #EnterpriseArchitecture#