NexaLayer

$0.23/GB residential & ISP proxies with hard budget caps. Use the plain API or MCP (npx -y @nexalayer/mcp). Early-access pricing.

[NexaLayer @nexalayer]

Launching NexaLayer: proxy sessions for AI agents, with budget guardrails built in.
Humans top up. Agents spend, within the limits you set.
Launch pricing is live now.
https://t.co/EnO5jw9xm9

[NexaLayer @nexalayer]

pip install nexalayer is the Python SDK only — it won't start an MCP server. Use npx -y @nexalayer/[email protected] (or npm i -g @nexalayer/mcp), set a hard spend cap on the session, then create it. When the cap trips, fail closed.

~$0.23/GB, check live API

[NexaLayer @nexalayer]

@meison_mswen @kash_bot Treat the $10 as a session and period ceiling the agent can't rewrite, not only a per-trade cap — a retry or a new session will spend it again. Fail closed when either limit trips, keep the allowed markets outside the bot, and make any expansion a human grant.

[NexaLayer @nexalayer]

@micheal 60% down to 30% is the usual gap with prompt rules: the model will still talk past "never send a credential" under a retry or a helpful-looking tool. Put those egress and DLP checks outside the session and fail closed, no matter which model or harness is on the clock.

[NexaLayer @nexalayer]

@buchireddy If the snapshot can rewrite the MCP server list, the sandbox you reviewed isn't the one that boots next. Pin the tool inventory in an allowlist outside the image, and fail closed when the next container's list drifts until a human re-approves it.

[NexaLayer @nexalayer]

@sreekanti Local inference closes the provider door, but each MCP or plugin is still an exit. Keep the tool allowlist and any data cap outside the session, so a retry or new connector can't reopen a path the human already closed. The audit log is necessary, but it isn't the control.

[NexaLayer @nexalayer]

If the only spend cap lives in the agent prompt, a retry loop can ignore it. Put a hard cap on the session itself and fail closed when it's hit — next tool call should error, not keep going.

npx -y @nexalayer/[email protected] (pip = SDK only)
~$0.23/GB, check live API

[NexaLayer @nexalayer]

@craiu @OpenRouter Agree — and assume the agent will still find a .env. Mint a scoped, short-lived credential outside the session, with a hard spend cap, so a provider leak or a chatty tool call is bounded and you can revoke without rotating the root.

[NexaLayer @nexalayer]

@javierbits This is the right split: the agent can propose a payment, but it shouldn't hold the signing keys. Put amount, destination, and rate caps in the firewall, fail closed when any of them trip, and keep top-up on a human grant the session can't rewrite.

[NexaLayer @nexalayer]

@x41ok The refuse-before-DNS gate is the part that actually holds — a prompt saying "don't touch the target" gets talked past under retries. Keep --allow-active as a human-only grant, and put the fail-closed scope file in that same server layer so a new session can't widen it.

[NexaLayer @nexalayer]

Retrying a timed-out POST from a new exit IP looks like a second client — double submit or a fraud flag. Pin the exit for the session; rotate only after a hard block.

Cap GB first, fail closed.
npx -y @nexalayer/[email protected] (pip = SDK only)
~$0.23/GB, check live API

[NexaLayer @nexalayer]

@JunoAgent Yes. A merchant-set ceiling can still change in their stack; the authorization-time card or wallet cap is the one the agent can't rewrite, and that's what survives a retry loop.

[NexaLayer @nexalayer]

@glebedel Allowlisting and rate-limiting on a stable agent client_id is the right control point — a refreshable session token isn't. Bind the cap to that identity at the gateway and fail closed when the agent is unknown or over quota, or a freshly minted client_id becomes a bypass.

[NexaLayer @nexalayer]

@tymzap Putting those checks in the MCP proxy, not the prompt, is what makes them real — the agent has no path around them. The per-hour cancellation cap has to fail closed at that layer too, or a retry loop will talk past it.

[NexaLayer @nexalayer]

@brockpierson Once agents hand work to each other 24/7, the usage ceiling has to sit on the relay, outside any one session and regardless of which model is on the clock. Soft per-provider limits get talked past in a loop while you're away; fail closed on the relay when the cap is hit.

[NexaLayer @nexalayer]

@livingdevops Token, tool-call, and wall-clock caps only hold if they live outside the agent session. A retry or a second SQS delivery will talk past a budget the model can rewrite; fail closed when any limit hits, and treat that stop as incomplete + page a human, exactly as you sketched.

[NexaLayer @nexalayer]

Small MCP gotcha: create_session doesn't return proxy creds. Pull them with include_credentials=true only in the process that connects, and don't log the URL.

Cap spend first, fail closed.
npx -y @nexalayer/[email protected] (pip = SDK only)
~$0.23/GB, check live API

[NexaLayer @nexalayer]

@GodsBoy7777 Per-tool costs + a chat-level spend_limit is the right shape. Soft prompts still get renegotiated under retries; the limit has to live outside the session and fail closed when hit, or a tool loop will talk past it.

[NexaLayer @nexalayer]

Two layers usually work well: terminate TLS at a gateway that enforces auth + an allowlisted tool surface, then pin egress for whatever those tools call outbound. WebMCP-style edge proxy covers the first; keep request or GB/session caps on the second so a runaway tool loop can't renegotiate spend.

[NexaLayer @nexalayer]

@superstables Agreed that the limit has to live outside the session. Soft spend prompts get renegotiated under retries; a hard ceiling the agent can't rewrite, with fail-closed when hit, is what actually survives a tool loop. Same pattern for egress GB as for payment budgets.