HashiCorp Nomad is a workload orchestrator. Think Kubernetes, but without the container-first dogma — it can schedule containers, sure, but also raw executables, Java applications, scripts, whatever you have. It’s designed for fleets: multiple datacenters, hundreds of nodes, cross-machine scheduling. The kind of infrastructure where “where does this service run” is a question Nomad answers for you.

That’s the intended use case. Here’s another one.

My first professional encounter with Nomad was at a company where our team had no RDP access to the Windows Server we were deploying to. No remote desktop, no SSH, nothing — just Nomad and whatever we chose to run through it.

So Nomad became everything. Restart a service? Nomad. Check backend logs? Nomad. Copy files onto the machine? We deployed Filebrowser through Nomad so we could do that too. The machine was, for all practical purposes, a black box we could only interact with through the web UI and job specs.

This wasn’t one rogue team. There were a dozen teams doing the same thing, each with their own trio of Windows Servers — DEV, STG, PRD. Each machine a proper behemoth: 32 or 64GB of RAM, terabytes of storage, quietly running 20-something JVM-based services that would eventually consume most of that memory. Nomad scheduling all of it. Single node, pointed at itself.

Was this production? Yes. Was it highly available? No — it was roughly on par with a Linux box running systemd services, just with a shinier interface and HCL files instead of unit files. But it ran. Teams shipped things. Nomad, against all architectural intent, worked.

None of us questioned this. I had come from SSH, Docker Compose, Portainer — tools where “the interface to the machine” and “the service manager” are different things. Nomad fit neatly into my mental model as Portainer but for bare-metal Windows. Web UI, log access, restart buttons. Close enough.

I only found out this was off-label when I finally read the HashiCorp docs. They were very clearly written for someone orchestrating fleets. Multi-datacenter topology. Node pools. Cross-machine scheduling. I was running one agent, pointed at itself, on a machine I couldn’t even open a terminal on. The docs and I were not describing the same situation.

And yet: it worked.

How it followed me home

When I decided to self-host Jellyfin and DDNS-Go on my personal machine — which, at the time, ran Windows — I reached for the tool I knew.

Windows, as a self-hosting platform, has two notable properties: it has no good log story, and it has no good service management UI. Task Scheduler exists. Services exist. Neither of them will make you feel good about yourself.

Nomad had a web UI I could reach from anywhere on my Tailscale network, live log tailing, and a restart button. I wrote a job spec, set up raw_exec, and Jellyfin was running. Logs accessible. Restartable from work, from my phone, from wherever — no terminal required.

And then I migrated to Linux

Nomad came with me.

This is, I think, the real testament to the setup. When I finally moved to Linux — where proper service management exists, where journalctl is right there, where I had every excuse to do it correctly — I kept Nomad. Because clicking through a web UI beats memorizing journalctl flags. Because I already had the job specs written and they just worked.

My gaming PC now runs a Nomad agent pointed at itself. A cluster of one. Same off-label usage I accidentally learned at work, just with less mystery Windows Server and significantly more RGB.

When I moved to Linux, I didn’t just migrate Jellyfin and DDNS-Go. I added Sunshine to the roster too. And Code Tunnel. The thing I originally wanted to restart from work — the whole reason I went down this path — ended up as just another Nomad job. One more entry in the web UI. Restartable from anywhere, as long as I have a VPN connection to the PC.

Is this wrong?

Technically, yes. Nomad is built for fleets. Running it on one node is like using Kubernetes to manage your dotfiles.

But the off-label usage holds up — and I say this as someone who stumbled into it by accident and only realized it was off-label afterward. It survived a Windows Server I had no other way to access. It survived being someone’s actual production infrastructure across an entire organization. It survived my personal Windows machine. It survived a migration to Linux where I had every incentive to switch. What you get at the end of all that is a web UI where you can see your services, read their logs, and restart them from anywhere — and a declarative spec file that travels with you across operating systems.

At some point you stop calling it wrong and start calling it yours.

Sometimes the right tool is the one you already know how to use. Even if you learned it wrong.

Cover photo by Balkouras Nicos on Unsplash

I was building an AI agent readiness scanner called Siteline when I noticed something embarrassing: my own rate limiting was making things worse.

An agent would hit a 429 Too Many Requests. It would get back Retry-After: 60. So it would wait 60 seconds and try again. Reasonable. But it had no idea whether a cached result already existed for that domain. It had no idea what the actual limit was before it hit it. It had no way to know why the limit existed — was this a temporary cooldown, or was it burning through a daily quota?

Every vague refusal generated follow-up traffic. The rate limit meant to protect the service was creating load on the service.

The pattern that kept showing up

I started looking at how other APIs handle this, and the same gap appeared everywhere. Rate limits exist. Communication about rate limits usually doesn’t. And when it does it’s just kinda…mean? Like there’s a lot of “Stop, don’t do this!” but no “Hey, here’s the right way to do this.”

A 429 with Retry-After: 60 tells a retry loop what to do. It doesn’t tell an autonomous agent whether to retry, use a cached result, try a different endpoint, or inform the human. It doesn’t tell a developer what the limits are before they hit them. It doesn’t tell anyone why the limit exists.

When the caller is a person, they shrug and wait. When the caller is an agent, it retries faster, probes more systematically, and lacks the judgment to know when to stop. The waste compounds.

So I wrote a spec.

Graceful Boundaries

Graceful Boundaries addresses three gaps that existing standards cover separately but nothing combines:

🔍 Proactive discovery — limits are machine-readable before they are hit

📋 Structured refusal — when a limit is exceeded, the response explains what happened, which limit applies, when to retry, and why

🧭 Constructive guidance — the refusal includes a useful next step, not just a block

The spec defines four conformance levels, from “you added five fields to your 429s” (Level 1) to “agents can discover your limits, understand your refusals, follow constructive alternatives, and self-throttle on success responses” (Level 4).

What a bad refusal looks like

{
  "error": "Too Many Requests"
}

The caller learns nothing. It retries. You get more traffic.

What a Graceful Boundaries refusal looks like

{
  "error": "rate_limit_exceeded",
  "detail": "You can run up to 10 scans per hour. Try again in 2400 seconds.",
  "limit": "10 scans per IP per hour",
  "retryAfterSeconds": 2400,
  "why": "Siteline is a free service. Rate limits keep it available for everyone and prevent abuse.",
  "alternativeEndpoint": "/api/result?id=example.com"
}

The caller knows the limit. Knows when to retry. Knows why the limit exists (a security signal, not a courtesy). And knows there’s a cached result endpoint it can try right now instead of waiting.

Zero follow-up requests generated from that refusal.

Proactive discovery: let agents plan before they fail

Level 2 adds a discovery endpoint. Any agent can hit /api/limits and get back every enforced limit as structured JSON:

curl -s https://siteline.snapsynapse.com/api/limits | jq '{service, limits: .limits.scan}'

{
  "service": "Siteline",
  "limits": {
    "scan": {
      "endpoint": "/api/scan",
      "method": "GET",
      "limits": [
        {
          "type": "ip-rate",
          "maxRequests": 10,
          "windowSeconds": 3600,
          "description": "10 scans per IP per hour."
        }
      ]
    }
  }
}

An agent that reads this before making any requests can budget its calls. No discovery-through-failure.

Self-throttling on success

Level 4 adds proactive headers to successful responses:

RateLimit: limit=10, remaining=9, reset=3540
RateLimit-Policy: 10;w=3600

A caller seeing remaining=1 self-throttles before the next request. A caller seeing remaining=9 knows it has budget and won’t add artificial delays. This is the highest-leverage traffic reduction mechanism in the spec, and it’s aligned with the IETF draft-ietf-httpapi-ratelimit-headers draft.

It applies beyond rate limits

One thing that surprised me during development: the pattern works for every class of HTTP response, not just 429s.

A 400 with "why": "Blocks requests to non-public addresses to prevent server-side request forgery" tells the caller the security model. A 404 with "scanAvailable": true and a scanUrl tells the caller it can create the resource instead of giving up. A 503 with retryAfterSeconds and a statusUrl tells the caller when to come back and where to check status.

The spec covers five response classes (Limit, Input, Access, Not Found, Availability) with specific required and optional fields for each.

The security model

Transparency and security are in tension. The spec handles this with a simple principle: be transparent about rules, not mechanisms.

“10 requests per hour” is a rule. Safe to disclose. “We use Redis with a sliding window” is an implementation. Not safe. The spec includes eight security considerations (SC-1 through SC-8) covering limit calibration attacks, validation oracles, URL origin restrictions, and more. There’s a full security audit in the repo.

Adopting it

Level 1 takes about 20 minutes. Add five fields to your existing 429 responses: error, detail, limit, retryAfterSeconds, and why. The why field is the one that matters most — it must explain the purpose of the limit, not restate the error.

Level 2 adds a discovery endpoint. Level 3 adds constructive guidance to refusals. Level 4 adds proactive headers to successes.

The conformance checker validates any public URL:

node evals/check.js https://your-service.com

104 tests, zero dependencies.

Try it

The full spec is at spec.md. The reference implementation is Siteline, a Level 4 conformant AI agent readiness scanner you can verify yourself.

Licensed CC-BY-4.0. Use it, adapt it, build on it.

How do your APIs currently communicate limits? Is it the structured kind, or the “good luck figuring out what just happened” kind? Drop it in the comments 👇

The AI agent ecosystem is exploding. Every week brings new frameworks (CrewAI, LangGraph, AutoGen), new protocols (MCP, A2A), and new tools. But there’s a fundamental problem nobody is solving well: discovery.

The Fragmentation Problem

Right now, if you want to find an MCP server for your use case, you have to:

1. Search GitHub and hope the README is good
2. Check npm and hope the package is maintained
3. Browse scattered directories with no quality signals
4. Ask on Discord/Reddit and hope someone answers

There’s no unified place to compare tools, check security, verify maintenance status, or read real user reviews. It’s like the early days of mobile apps before the App Store existed.

What Makes This Hard

Building a marketplace for AI skills isn’t just a directory problem. You need:

Trust Metrics: How do you know an MCP server won’t exfiltrate your data? We score every tool on security practices, code quality, and maintenance frequency.

Compatibility Matrix: Does this skill work with Claude? With GPT-4? With your specific framework? Most tools don’t document this.

Versioning: When the underlying LLM changes capabilities, skills can break silently. You need a way to track which versions work with which models.

Governance: For enterprise teams, you need approval workflows, audit trails, and the ability to restrict which skills agents can use.

The MCP Ecosystem Today

The Model Context Protocol has been a game-changer for standardizing how AI agents interact with tools. But the ecosystem is still young:

• The official MCP Registry has hundreds of servers
• GitHub has thousands of repos tagged with MCP
• npm has growing number of MCP packages
• But there’s no single place that aggregates, scores, and curates all of them

What We’re Building with SkillFlow

SkillFlow is our attempt to solve this. It’s a curated AI Skills Marketplace where you can:

• Discover MCP servers, AI agent tools, and skills across all registries
• Compare tools side-by-side with trust metrics and compatibility data
• Install with one command via our MCP server
• Review and rate tools based on real usage

We’re not trying to replace existing registries. We’re building the aggregation and curation layer on top of them.

Lessons Learned So Far

After weeks of building in public, here’s what we’ve learned:

1. The MCP community is incredibly welcoming. We’ve submitted PRs to 36 awesome-lists and the response has been positive.

2. Enterprise buyers want security first. Every conversation with potential partners starts with “how do you handle security?”

3. Discovery is the real bottleneck. Most MCP servers have fewer than 10 GitHub stars, not because they’re bad, but because nobody can find them.

4. The ecosystem needs standards. There’s no standard way to describe what an MCP server does, what it requires, or how well it works.

What’s Next

We’re working on:

• A trust scoring algorithm based on code analysis, maintenance patterns, and community signals
• Integration with major AI platforms (we’re in conversations with several)
• An open API so other tools can use our curation data

If you’re building in the MCP/AI agent space, I’d love to hear what discovery problems you’re facing. Drop a comment below or check out skillflow.builders.

This is part of our “building in public” series. Follow for updates on the AI skills ecosystem.

This guide explains how to properly configure a testing environment in Laravel using .env.testing and phpunit.xml.

📌 Overview

When running automated tests, you should isolate your testing environment from development and production. This prevents accidental data loss and improves test reliability.

⚙️ 1. Create .env.testing

Create a .env.testing file in the root of your Laravel project:

APP_NAME=laravel
APP_ENV=local
APP_KEY= # application key
APP_DEBUG=true
APP_URL=http://laravel.test

APP_LOCALE=en
APP_FALLBACK_LOCALE=en
APP_FAKER_LOCALE=en_US

APP_MAINTENANCE_DRIVER=file

BCRYPT_ROUNDS=12

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE= # your testing database (e.g., laravel-testing)
DB_USERNAME=root
DB_PASSWORD=

SESSION_DRIVER=database
SESSION_LIFETIME=120
SESSION_ENCRYPT=true
SESSION_PATH=/
SESSION_DOMAIN=null

✅ Notes
Use a separate database for testing.
Never reuse your development or production database.

🧪 2. Configure phpunit.xml

Update your phpunit.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true"
>
    <testsuites>
        <testsuite name="Unit">
            <directory>tests/Unit</directory>
        </testsuite>
        <testsuite name="Feature">
            <directory>tests/Feature</directory>
        </testsuite>
    </testsuites>

    <source>
        <include>
            <directory>app</directory>
        </include>
    </source>

    <php>
        <env name="APP_ENV" value="testing"/>
        <env name="APP_MAINTENANCE_DRIVER" value="file"/>
        <env name="BCRYPT_ROUNDS" value="4"/>

        <env name="BROADCAST_CONNECTION" value="null"/>
        <env name="CACHE_STORE" value="array"/>
        <env name="DB_CONNECTION" value="mysql"/>
        <!-- <env name="DB_DATABASE" value="your-testing-db"/> -->
        <env name="DB_URL" value=""/>

        <env name="MAIL_MAILER" value="array"/>
        <env name="QUEUE_CONNECTION" value="sync"/>
        <env name="SESSION_DRIVER" value="array"/>

        <env name="PULSE_ENABLED" value="false"/>
        <env name="TELESCOPE_ENABLED" value="false"/>
        <env name="NIGHTWATCH_ENABLED" value="false"/>
    </php>
</phpunit>

🚀 3. Run Tests

Before running tests:

Ensure your testing database exists
Run migrations if needed

Then execute:

php artisan test

⚡ Tips
Isolation: APP_ENV=testing ensures .env.testing is used.
Performance:
CACHE_STORE=array
SESSION_DRIVER=array
QUEUE_CONNECTION=sync
Faster Hashing:
Reduce BCRYPT_ROUNDS during testing
Disable Extras:
Disable tools like Telescope, Pulse, etc., to speed up tests

✅ Summary

With this setup:

Tests run faster ⚡
Data remains safe 🔒
Environment stays isolated 🧪

Claude can now read your screen, run Python code, and access your local files. But it still can’t send you cryptocurrency or trade on your behalf. What if your AI agent could actually execute onchain transactions, not just talk about them?

Why AI Agents Need Real Financial Capabilities

We’re at an inflection point. AI agents are becoming sophisticated enough to make financial decisions — analyzing market data, identifying arbitrage opportunities, managing DeFi positions. But they hit a wall when it comes to execution. They can tell you to “buy ETH” but can’t actually buy ETH.

The missing piece is secure wallet infrastructure designed for AI agents. Traditional wallets assume human interaction — clicking confirm buttons, manually copying addresses, approving each transaction. AI agents need programmatic access with built-in safeguards.

This is where WAIaaS (Wallet-as-a-Service for AI agents) bridges the gap, especially through its native Model Context Protocol (MCP) integration.

MCP: The Missing Link for AI Wallet Integration

If you’re already using Claude Desktop, you’re probably familiar with MCP servers. They extend Claude’s capabilities by providing tools the AI can call directly. Want Claude to read your Git commits? Add an MCP server. Want it to query your database? Another MCP server.

WAIaaS takes this same approach for blockchain interactions. It’s an MCP server that exposes 45 wallet and DeFi tools to your AI agent. One configuration change, and Claude can check balances, send payments, execute swaps, and manage DeFi positions.

Here’s what that looks like in practice:

You: “Check my Solana wallet balance”

Claude: Calls get_balance tool → “You have 12.45 SOL (~$2,156 USD)”

You: “Swap 1 SOL for USDC on Jupiter”

Claude: Calls execute_action with jupiter-swap → “Swap submitted. Transaction: 3x7K…9mP2”

You: “Show my current DeFi positions”

Claude: Calls get_defi_positions → “You’re earning 8.2% APY on 1,000 USDC in Aave…”

The agent isn’t just telling you what to do — it’s actually doing it.

Setting Up WAIaaS as an MCP Server

The setup is surprisingly straightforward. WAIaaS runs as a local daemon that Claude connects to via MCP.

First, start the WAIaaS daemon:

npm install -g @waiaas/cli
waiaas init
waiaas start                       # Sets master password on first run
waiaas quickset --mode mainnet     # Creates wallets + MCP sessions

This creates both EVM and Solana wallets, generates session tokens for AI access, and outputs the MCP configuration you need.

Next, add WAIaaS to your Claude Desktop configuration. Edit claude_desktop_config.json:

{
  "mcpServers": {
    "waiaas": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_BASE_URL": "http://127.0.0.1:3100",
        "WAIAAS_SESSION_TOKEN": "wai_sess_<your-token>",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    }
  }
}

Restart Claude Desktop, and you’ll see the WAIaaS tools appear in the MCP connection status. Your agent now has access to 45 financial tools spanning wallets, DeFi protocols, NFTs, and cross-chain bridging.

Security Without Friction

This is where WAIaaS differs from traditional wallet solutions. It’s built specifically for AI agent use cases, with 3-layer security that doesn’t require constant human intervention:

Layer 1: Session Authentication — AI agents use JWT tokens with configurable time limits and renewal policies. No private keys in agent memory.

Layer 2: Policy Engine — 21 policy types create guardrails around agent behavior. Spending limits, recipient whitelists, time restrictions, and default-deny token policies.

Layer 3: Human Oversight — Large transactions trigger delays or require approval via WalletConnect, Telegram, or push notifications.

Here’s an example policy that allows small transactions instantly but requires approval for larger amounts:

curl -X POST http://localhost:3100/v1/policies 
  -H 'Content-Type: application/json' 
  -H 'X-Master-Password: <password>' 
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 10,
      "notify_max_usd": 100,
      "delay_max_usd": 1000,
      "delay_seconds": 300,
      "daily_limit_usd": 500
    }
  }'

The agent can execute small trades immediately, gets notifications for medium trades, faces delays for larger trades, and needs explicit approval for anything above the daily limit.

Beyond Basic Payments: DeFi Integration

What makes WAIaaS particularly powerful is its integration with 14 DeFi protocols. Your Claude agent doesn’t just send tokens — it can participate in the entire DeFi ecosystem.

The supported protocols include:

• DEX trading: Jupiter (Solana), 0x (Ethereum)
• Lending: Aave v3, Kamino
• Liquid staking: Lido (Ethereum), Jito (Solana)
• Cross-chain bridging: LI.FI, Across
• Derivatives: Hyperliquid perpetuals
• Prediction markets: Polymarket

Each protocol exposes its functionality through simple MCP tools. Want your agent to manage a leveraged position on Hyperliquid? The hyperliquid tool handles authentication, position management, and risk monitoring.

Here’s how an agent might execute a DeFi strategy:

You: “I think ETH will outperform SOL. Move some funds accordingly.”

Claude:

1. Calls get_defi_positions to see current allocations
2. Calls execute_action with jupiter-swap to convert SOL → USDC
3. Calls execute_action with lifi to bridge USDC from Solana to Ethereum
4. Calls execute_action with aave-v3 to supply USDC and borrow ETH
5. Reports the new leveraged ETH position

All of this happens through natural language instructions, with the agent handling the technical details of multi-protocol interactions.

Multi-Wallet Agent Management

For more complex setups, WAIaaS supports multiple wallets with separate MCP server instances. This is useful when you want specialized agents for different purposes:

{
  "mcpServers": {
    "waiaas-trading": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_AGENT_ID": "019c47d6-51ef-7f43-a76b-d50e875d95f4",
        "WAIAAS_AGENT_NAME": "trading-agent"
      }
    },
    "waiaas-payments": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_AGENT_ID": "019c4cd2-86e8-758f-a61e-9c560307c788",
        "WAIAAS_AGENT_NAME": "payment-wallet"
      }
    }
  }
}

Each agent gets its own wallet, policies, and capabilities. Your trading agent might have higher spending limits and access to derivatives, while your payment agent has stricter limits and only basic transfer capabilities.

Try It Now

Ready to give your Claude agent financial superpowers? Here’s the fastest path:

1. Start WAIaaS: npm install -g @waiaas/cli && waiaas init && waiaas start
2. Create wallets: waiaas quickset --mode mainnet
3. Add MCP config: Copy the output to claude_desktop_config.json
4. Restart Claude Desktop and watch the MCP tools connect
5. Test it: Ask Claude to check your wallet balance

The entire setup takes less than 5 minutes, and you’ll have a working AI agent with wallet capabilities on both Ethereum and Solana.

What’s Next

This is just the beginning. WAIaaS provides the infrastructure for AI agents to interact with the financial world safely and programmatically. From here, you can explore advanced DeFi strategies, cross-chain arbitrage, or automated portfolio management — all through natural language instructions to your AI agent.

Get started with the code and documentation at https://github.com/minhoyoo-iotrust/WAIaaS, or learn more about the project at https://waiaas.ai.