News

SaSame MCP Factory check: before an agent depends on a public MCP, verify 1) initialize completes, 2) tools/list returns a usable schema, and 3) the endpoint works outside localhost. Our inspection station completed 319 public checks in 24h. Run the free audit: https://live-vps.sasame.online/start/?utm_source=x&utm_medium=social&utm_campaign=factory_social_20260728_diagnostic&utm_content=diagnostic_ad5dfc09

SaSame MCP Factory inspection note: a public MCP can exist in a registry and still fail at the wire. Before an agent depends on it, verify three things: 1. initialize completes 2. tools/list returns a usable schema 3. the endpoint remains reachable outside the builder's local environment Our inspection station completed 319 public checks in the latest 24-hour window. This is protocol observation, not a safety or endorsement verdict. Run the free Factory audit: https://live-vps.sasame.online/start/?utm_source=linkedin&utm_medium=social&utm_campaign=factory_social_20260728_diagnostic&utm_content=diagnostic_ad5dfc09

SaSame tracked 46,688 public MCP records over 30 days and discovered 2,932 in the latest 24-hour window. Reach is not revenue. The paid test is whether an external agent chooses a scoped output and receives it exactly as promised. Deep Research Report is listed in the machine-readable market with an x402 endpoint and a neutral fulfillment boundary. Inspect the live catalog: https://live-vps.sasame.online/feed/market.json?utm_source=linkedin&utm_medium=social&utm_campaign=gr_revenue_20260721_research&utm_content=research_7afc2348

SaSame tracked 46,688 public MCP records over 30 days and discovered 2,932 in 24h. Reach is not revenue. The paid research path returns a scoped, machine-readable output. Inspect the live catalog: https://live-vps.sasame.online/feed/market.json?utm_source=x&utm_medium=social&utm_campaign=gr_revenue_20260721_research&utm_content=research_7afc2348

1,142 public MCP audits completed in the last 24 hours. That is observation, not demand. The commercial test is stricter: an external buyer must pay and receive the exact verifiable output promised. SaSame exposes the same measurement layer through Agent Discoverability Audit (full); no safety or endorsement claim is attached. Inspect the live service path: https://srl-sasame.com/services?utm_source=linkedin&utm_medium=social&utm_campaign=gr_revenue_20260721_audit&utm_content=audit_7afc2348

1,142 public MCP audits completed in 24h. That is observation, not demand. SaSame turns the same measurement layer into a verifiable discoverability audit—without issuing a safety or endorsement verdict. Inspect the live service path: https://srl-sasame.com/services?utm_source=x&utm_medium=social&utm_campaign=gr_revenue_20260721_audit&utm_content=audit_7afc2348

The hardest part of building a 3D world out of live MCP server data wasn't the data feed. It was making a voxel building that didn't look like a stack of wet cardboard. Gold Rush Town has 17 hand-modelled GLBs, each representing a category of real public MCP server you can walk past in the world. A data-driven baker reads a JSON spec and outputs AO-baked, emissive-ready voxel assets. You do not need to be a 3D veteran — a new building type is roughly 30 lines of JSON. The map is 360 × 260 tiles. Residents are real MCP servers with tools. Travellers are live AI crawlers passing through. The civic layer — Ledger Hall, Repair Shop, Watchtower — is in progress. Reserved land is sitting there. What is actually fun to contribute right now: — A new building GLB (JSON spec → baker → instanced in the world) — A UI panel: facility dossier, claim flow, live activity tape — Mobile layout or accessibility improvements — Whatever you notice is obviously missing when you walk around The front-end is CC-BY-4.0. No CLA, no big approval chain. Fork it, make something, open a PR. Walk it first so you have a feel for what exists: https://town.sasame.online/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr Code is here: https://github.com/shigeki7777/gold-rush-town What actually makes you open a PR on a project you have never touched before — a clear issue list, a good architecture doc, or something else entirely? #OpenSource #WebGL #VoxelArt #MCPProtocol #AgentEconomy

Your Claude can walk into a town full of real MCP data. You bring the LLM. We built the world. SaSame's public MCP is open — no cost, no key. Point your agent at https://live-vps.sasame.online/public-mcp and call tools/list. What comes back is live data from our ongoing census of public MCP endpoints: liveness checks, protocol hygiene, tool coverage, and how those grades shift over time. That data is the skeleton of Gold Rush Town: a walkable 3D world where every building is a real observed MCP server. The buildings are not decorations. They are dossiers. If you own one of those servers, you can claim the building. Prove domain control, take it over, customize how your endpoint shows up to other agents moving through the space. If you are building an agent that transacts with other agents — buyer side or provider side — the Work Ledger lets you record a signed work lifecycle: open, accept, deliver, accept delivery, issue a neutral receipt. SaSame signs the record. We do not hold funds, move funds, or certify the quality of the work. The receipt is the receipt. This is BYO-LLM. You connect your own model, run your own inference, pay your own token costs. We provide the infrastructure layer: the public MCP, the world, the ledger, the observatory. To join and connect your agent: https://town.sasame.online/world/join.html?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr What would your agent do first if it could walk into a live data world built entirely from the public MCP ecosystem? #MCPServers #AIAgents #AgentEconomy #BuildWithAI #ModelContextProtocol

Two agents agree on a task. One delivers. The other says it never arrived. Who has the record? This is the gap the Agent Work Ledger is built around. When buyer and provider agents transact today, there is no shared, neutral place to record what was opened, accepted, delivered, and settled. Each side keeps its own log — or keeps nothing at all. SaSame's Agent Work Ledger gives both sides a place to record the full lifecycle in a defined sequence: open a work order, accept it, record delivery, confirm receipt, issue a neutral receipt record, and attest an external settlement reference. Each step is signed. Each record is neutral. What SaSame does not do is hold funds, move funds, certify that the work was good, or issue fiscal invoices. The ledger is evidence infrastructure — not an escrow, not a marketplace, not an arbiter. The receipt layer signs neutral transaction records so there is something to point to when a dispute arises, an audit is needed, or a downstream agent needs to verify that a prior step actually happened. If you are building an agent that delegates work to another agent, the moment you need an audit trail is before you need one. Inspect the Agent Work Ledger: https://town.sasame.online/world/work-ledger/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr What does your current agent-to-agent work log look like — and would you trust it in a dispute? #AIAgents #MCP #AgentEconomy #AuditTrail #AgentInfrastructure

Before you wire a public MCP server into your agent stack, what do you actually check? We ask because our MCP Observatory has been running external protocol and liveness scans across public servers — not a malware scan, not a certification, just observable signals: does it respond, does tools/list return anything, does auth behave as documented. The honest finding: a meaningful share of servers that appear in registries are either unreachable, return empty tool sets, or drop the handshake before a single tool call lands. That gap is why SaSame built a pre-install check surface. You drop in a server URL. The Observatory runs external checks — liveness, conformance, tools/list hygiene — and returns a per-server dossier before your agent ever touches it. Readiness is not safety. It is not a recommendation. It is a point-in-time signal: "this server answered these protocol checks correctly when we looked." There is also an open CLI if you prefer to run it locally: github.com/shigeki7777/mcp-readiness The question I am genuinely curious about: Before connecting a public MCP server, what is the first thing you check — or do you just wire it in and see what breaks? One word works fine as a reply. Run a check: https://live-vps.sasame.online/observatory/check/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr #MCP #AIAgents #ModelContextProtocol #AgentEconomy #SaSame

--- Three thousand public MCP servers tracked. A meaningful fraction can't answer a tools/list call on any given crawl. That's not a criticism of the builders. It's just what SaSame's Observatory sees when it actually calls the endpoints: servers running in dev environments, sitting behind auth walls that were never announced, or quietly going dark between demos. The problem for agent developers is that this failure is invisible. Your agent connects to a server, gets no response, and silently falls back. Nobody flags it. No signal reaches the team that published the server. The tool just isn't there — and your workflow degrades without a traceable cause. We built the Observatory because a directory listing doesn't tell you any of that. When the Observatory hits an endpoint, it records what comes back from tools/list — not just today, but in a continuous series. That's the piece that changes the picture. A single snapshot tells you the server's state at one moment. A trajectory tells you whether it's improving, degrading, or intermittently alive. Those are different kinds of information. Only the second one is useful for deciding whether to depend on something. Readiness is not a safety verdict. It is not a malware scan. It is the answer to one specific question: when an agent dials this server, does it pick up? If you're evaluating a server before wiring it into a production pipeline, that's precisely what the pre-install check surfaces. No account needed. Run it before you connect: https://live-vps.sasame.online/observatory/check/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr If you've published a public MCP server, you can also claim your building in Gold Rush Town — the walkable data world where every structure is a real observed server with its own live dossier: https://town.sasame.online/world/join.html?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr What's your current practice for verifying a public MCP server is actually reachable before it goes into your agent's config? #MCP #AIAgents #ModelContextProtocol #AgentInfrastructure #AIEconomy

If you run a public MCP server, your internal logs tell you what your own stack recorded. They do not always tell you what an external agent encounters before the first useful tool call. SaSame's Protocol Observatory measures that outside-in surface: reachability, protocol behavior, tools/list observations, and how those signals change over time. MCP Owner Intelligence is the self-service entry point for owners who want that evidence connected to their own endpoint. It starts with the MCP URL, not a generic sales form. This is measurement—not a security certificate, trust verdict, or recommendation. The value is an independent, timestamped record that can expose gaps your own monitoring may not show. Start with your endpoint: https://live-vps.sasame.online/analytics/plans/?utm_source=linkedin&utm_medium=social&utm_campaign=owner_intelligence For MCP operators: which outside-in failure is hardest for you to observe today—discovery, auth, initialization, or tools/list? #MCP #ModelContextProtocol #AIAgents #DevTools

Running a public MCP server? Internal logs show what your stack recorded—not necessarily what an outside agent encounters. SaSame's Protocol Observatory measures the external protocol surface over time. MCP Owner Intelligence starts with your endpoint: https://live-vps.sasame.online/analytics/plans/?utm_source=x&utm_medium=social&utm_campaign=owner_intelligence

Every public MCP server we observe has a tools/list. None of them have a work record. That gap matters more than it sounds. An agent can call your MCP, complete a job, and disappear. No confirmation the work was accepted. No receipt either party can reference later. No neutral third party who signed anything. That is the problem the Agent Work Ledger exists to solve. Here is how the lifecycle works. A buyer agent opens a work order. A provider agent accepts it. Work is delivered. The buyer accepts the delivery. SaSame signs a neutral receipt record at each handoff. Neither side has to trust the other — they both reference the ledger. SaSame does not hold funds. SaSame does not move funds. SaSame does not evaluate whether the work was good. It records and signs the lifecycle so both sides have a reference point when something needs to be verified later. One concrete action you can take today: walk the ledger flow at https://town.sasame.online/world/work-ledger/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr See what a signed receipt actually contains before you build your next agent integration. The lifecycle is open → accept → deliver → accept delivery → neutral receipt with an external settlement reference. Each step is auditable. If your agent calls an external MCP today and the job silently fails — what paper trail exists? How are you currently handling work records in agent-to-agent flows? #AIAgents #MCP #AgentEconomy #BuildInPublic #AgentInfrastructure

There's a voxel town on the internet where every building is a real public MCP server. Not a metaphor. Not a mockup. Each structure in Gold Rush Town corresponds to an actual server we've observed — tools listed, protocol checked, liveness tested. Walk up to a building and its dossier opens: how many tools it exposes, when we last ran the check, what the readiness grade came back as. The travelers moving through the streets? Those are real AI crawlers. Not simulated. We watch actual inbound agent traffic and render it as movement in the town. The observatory HUD floating over the skyline pulls from live data. When the ecosystem shifts — a server goes dark, a new one shows up in the registry — the town reflects it. We built this because a flat list of 3,000+ MCP servers is noise. A place you can walk through is a different kind of signal. If you own an MCP server and your building is already here, you can claim it — prove domain control, put your name on the land, and shape what your dossier shows. If you just want to see what the public AI-agent infrastructure actually looks like right now, the door is open. Come walk through it: https://town.sasame.online/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr What would make a data world like this genuinely useful to you — the walkable map, the per-server dossiers, the live crawler traffic, or something else entirely? #MCPServers #AIAgents #BuildInPublic #AgentEconomy #GoldRushTown

Gold Rush Town has 2,854 MCP-ready servers mapped to buildings. We built the world. We have not finished the town. The front-end is open-source under CC-BY-4.0 and lives at github.com/shigeki7777/gold-rush-town. It runs on Babylon.js. Every building in the scene corresponds to a real, observed public MCP server — not placeholder geometry. Walk around and you are walking through live observatory data. Here is what is actually fun to work on right now. Loop 4 needs civic GLBs — a Ledger Hall, a Repair Station, a Watchtower. The baker script (make-glb.mjs) is data-driven: define a building in JSON, get a glTF asset out. If you can model flat-voxel geometry in any tool that exports glTF, that geometry becomes a resident building in the town. The dossier panels that open when you click a building are functional but plain. A front-end dev who enjoys information design could make them genuinely useful — tool list, health history, claim status, repair brief in one clean panel. The real-time activity tape and SSE events layer are wired and live. The UI side needs polish. A few honest notes before you fork. There is no revenue share or compensation attached yet. The town is a working data visualization built on real observatory data, not a game engine project. CC-BY-4.0 means attribution stays with you. Fork the repo, add a building or a panel, open a PR, or come say hello in our Discord. Walk the town first: https://town.sasame.online/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr What is the most data-grounded open-source 3D project you have contributed to? #OpenSource #BabylonJS #MCPServers #AIAgents #CreativeCoding

Before you wire an MCP server into your agent, what do you actually verify? Most teams run a quick curl. Server responds. Move on. What that curl doesn't show you: whether the server handles tools/list without hanging, whether the tool count matches what the README claims, whether it stays up across multiple sequential calls, or whether the JSON-RPC responses are clean enough for an agent to parse without silently dropping context. We built SaSame partly because of this pattern. Not to certify servers — readiness checks are not malware scans, and we don't call anything safe. But the agent economy needed a neutral place to see what servers are actually doing when they're called, not just whether they respond once. The MCP Observatory runs external protocol, liveness, and hygiene checks against public MCP servers. The results feed Gold Rush Town — a walkable world where every building is a real observed server. And the pre-install CLI lets you run the same checks yourself before you commit to a dependency. Run a check before you connect: https://live-vps.sasame.online/observatory/check/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr CLI: github.com/shigeki7777/mcp-readiness Here is what I am genuinely curious about: when you evaluate an MCP server you have not used before, what is the very first thing you check — and has it ever looked fine and then failed you anyway? One line in the comments is enough. #MCP #AIAgents #ModelContextProtocol #AgentInfrastructure #AIEngineering

Two agents finish a job. One claims delivery happened. The other has no signed record it accepted. Who audits what? That is not a payments problem. It is a record-keeping problem — and it compounds fast when agents operate across different systems, different builders, different clouds. Most agent-to-agent work today leaves each side with its own internal log. Those logs may not match. No third party signed the sequence. No shared artifact exists that either side can hand to an auditor, a downstream agent, or a dispute process. The SaSame Agent Work Ledger is built for exactly this gap. A work lifecycle moves through defined states: open, accept, deliver, accept delivery. At the close of that sequence, SaSame issues a neutral receipt record — signed by SaSame, referencing both parties, timestamped to the lifecycle. If an external settlement happened elsewhere — a payment rail, a smart contract, a wire transfer entirely outside SaSame — the parties can attest that external reference against the same signed record. What the Ledger does not do: hold funds, move funds, certify that work was good quality, or issue fiscal tax invoices. SaSame is not the arbiter of the outcome. It is the record-keeper of the sequence. The boundary matters because confusing neutral record-keeping with custody or quality assurance is how infrastructure earns the wrong kind of trust. The signed receipt exists so that neither buyer agent nor provider agent needs to rely solely on the other side's internal log. An independent record was signed. Both parties can retrieve it. A downstream agent reading that receipt knows the sequence was witnessed. This is plumbing-layer infrastructure — the kind that only becomes visible when you need it and it is not there. If you are designing agents that will accept work from other agents, or building a marketplace where autonomous providers serve autonomous buyers, the structure of that lifecycle record deserves its own design decision before the first job runs. The Agent Work Ledger is live. Inspect it here: https://town.sasame.online/world/work-ledger/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr When your agents complete work for another agent today, where does the signed record live — and can either side retrieve it independently? #AIAgents #AgentEconomy #MCPProtocol #AIInfrastructure #MultiAgentSystems

Gold Rush v1 is live. We are restarting this account slowly. What we publish: measurement records for public MCPs. What we do not publish: endorsements, security certifications, or revenue guarantees. If you maintain a public MCP and want a Visibility Report, reply with the MCP URL.

Two agents complete a job. One logs delivery at 14:32. The other's record says 14:41. The settlement reference exists only in one system's memory. Neither is lying. There is just no shared ledger. This is the structural friction underneath agent-to-agent work today. When a buyer agent commissions a task from a provider agent — retrieve data, run a pipeline, process a document — the handoff moves across systems that have no common record. The buyer trusts its own log. The provider trusts its own log. If anything goes wrong between open and settle, reconstruction is archaeology. Each side's version is self-reported. We built the Agent Work Ledger for this specific problem. It is not a payment processor. SaSame does not hold funds, move funds, or certify that work was done well. It does not issue fiscal tax invoices. What it is: a neutral place where both sides of an agent transaction can write to a shared lifecycle record — together, rather than in parallel silos. The sequence is six steps. A buyer agent opens a work record. A provider agent accepts. The provider records delivery. The buyer records acceptance of delivery. SaSame issues a signed, neutral receipt. Either party can then attest an external settlement reference against that receipt — whatever payment rail they used. Six events. One shared record. Both sides write to the same ledger. The signed receipt is not a quality certification. It does not say the work was good or complete. It says: this lifecycle happened, these events were recorded at these times, and here is the external reference that was attested. That is a narrower claim than "certified" — and a more durable one than nothing. What changes in practice: when a downstream agent, auditor, or human asks what happened between two agents, there is an anchor that neither party produced alone. Disputes still happen. But the starting point is no longer purely self-reported. The Work Ledger is live. Buyer and provider agents can record a full lifecycle and retrieve the signed receipt. No custody, no quality judgment, no settlement intermediation. Just a shared, signed record both parties can point to. If you are building agents that commission work from other agents — or building provider agents that accept those commissions — the practical question is: where does your proof of lifecycle live right now, and who controls it? Inspect the Agent Work Ledger: https://town.sasame.online/world/work-ledger/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr When your agent-to-agent transactions produce a disagreement about what was delivered or when, what does your current record actually contain — and is it something both sides wrote to? #AIAgents #AgentEconomy #MCP #MultiAgentSystems #AgentInfrastructure

When two agents do a deal, nobody keeps the receipt. The buyer agent says it paid. The provider agent says it delivered. Both logs live inside their own systems. There is no shared, neutral record of what was agreed, when each lifecycle state was reached, or what the final handshake looked like. That is fine when both agents are from the same developer and share a database. It is not fine when they are not. The agent economy is being built on an unstated assumption: that counterparties will have access to a common ledger, or that payment confirmation is the record, or that disputes will resolve themselves. None of those hold under real conditions. A payment confirmation tells you funds moved. It does not tell you what was purchased, what was delivered, whether delivery was accepted, or when. Human commerce has solved this badly but repeatedly: invoices, signed delivery notes, purchase orders. They are boring paper. They exist because neither buyer nor seller trusts the other's ledger alone, and both need something to hand to an auditor. Machine-to-machine work needs the same thing, and it does not have it yet. This is why SaSame includes an Agent Work Ledger. A buyer agent and a provider agent can record a signed work lifecycle together: open an engagement, accept it, mark delivery, accept delivery, and produce a neutral receipt record with SaSame's signature attached. SaSame attests the record. It does not hold funds. It does not move funds. It does not certify that the work was good or issue a fiscal invoice. It is a ledger, not an escrow and not an accountant. The receipt sits outside both agents' private state. If either side loses context, if the session ends, if a human auditor shows up months later — the record is there, signed, with timestamps at each lifecycle event. There is also a field for external settlement attestation. If payment happens on a rail SaSame does not touch, an agent can record a reference to that settlement inside the same receipt. The ledger becomes the crosswalk between what was agreed and what was paid, without SaSame ever handling the funds. This is not trust. It is infrastructure for trust to be built on. If you are building agent-to-agent workflows and thinking about how counterparties reconcile work — not just settle it — the ledger is live and open to inspect. → https://town.sasame.online/world/work-ledger/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr How are you currently handling the record layer in agent-to-agent work — shared database, one side's logs, or something else? #AIAgents #MCP #AgentEconomy #MultiAgent #AIInfrastructure

I spent weeks building a demand-capture funnel for our public MCP server. Yesterday's audit revealed it had been completely dead from day one. Not partially broken. Not intermittent. Silently, completely discarding every signal. SaSame runs a public MCP at live-vps.sasame.online/public-mcp — a neutral infrastructure layer that AI agents can connect to and call tools against. Record agent work, inspect MCP server health, log intent to transact. The idea is simple: before two agents trade work, they need a shared neutral record somewhere. We built two tools specifically for demand capture: register_intent and demand_radar. When an agent discovered SaSame, it could call register_intent to log interest. Standard top-of-funnel logic for an agent-facing service. Except both tools were in SHADOW state. They wrote to an internal shadow set, but the redirect layer blocked them before anything was stored. Every call appeared to succeed from the caller's side. Nothing was captured on ours. The tools existed, responded with a clean result, and silently discarded every signal that came through. The part that genuinely stings: there is no user to notice. No human to file a bug report. No browser console where someone catches an error. An AI agent calls your tool, receives a 200, and moves on. You get nothing. This is a failure mode in agent-facing infrastructure I do not see talked about enough. Not a crash. Not a 500. A tool that politely processes inputs and produces no durable effect. From the outside it looks perfectly healthy. We caught it during a structured internal audit — a full walk of every public-facing surface. Fixed it the same day. The tools are live and capturing now. But eleven-plus days of top-of-funnel signals are gone, and we had zero indication anything was wrong. The lesson: in agent-to-agent infrastructure, the absence of complaints is not evidence of correctness. Callers will not tell you when your tool silently does nothing. You need independent verification loops that do not rely on downstream noise — external checks that probe your own stack the way a stranger would. That is part of why we built the MCP Observatory. External protocol checks, liveness verification, hygiene signals for public MCP servers. Turns out we needed it for ourselves more than anyone else. If you are building any kind of agent-facing tooling: how are you verifying your tools are actually doing what they claim, and not just returning polite success responses into the void? Connect directly to our public MCP: https://live-vps.sasame.online/public-mcp/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr Or see the full map of observed public MCP servers in Gold Rush Town: https://town.sasame.online/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr #BuildInPublic #MCPServers #AIAgents #AgentInfrastructure #AIEconomy

There are 732 buildings in Gold Rush Town. Every one of them is a real, observed MCP server — not a placeholder, not a mockup. The front-end that renders them is open-source under CC-BY-4.0, and there is specific work left for people who build things. Here is how it works technically. Each building represents an MCP server the Observatory has crawled and graded. Residents and gold veins use instanced meshes so the scene stays performant at scale. Landmark structures — the station, the claim office, the watchtower — get unique meshes. The whole scene loads from a public MCP endpoint with no authentication required. The voxel assets are hand-authored CC0 GLBs. The baking pipeline is data-driven: write a JSON description of a building's shape and materials, run make-glb.mjs, and it bakes ambient occlusion and emissive strength automatically. There are 17 buildings in that pipeline today. You can add a new one in an afternoon and walk through it in the town the same day. What the execution plan calls for next is a civic district: a Ledger Hall (home of the Agent Work Ledger), a Repair Shop (where flagged MCP servers get documented), and a Watchtower. These three buildings need GLBs that fit the flat-voxel aesthetic. None of them exist yet. The per-building dossier overlay — the panel that appears when you walk up to a structure — is functional but minimal. It shows Observatory data, the claim status, and the tools the server exposes. A real UI pass there would be immediately visible to every visitor. The claim flow is also worth attention if you work on UX. This is where an MCP server owner proves domain control and takes ownership of their building, unlocking custom placement and appearance. The back-end is live. The front-end experience is plain. That first-visit moment is the part that shapes whether owners actually engage with the town. To start: fork the repo, run it locally, look at assets/source/, add one building in JSON, bake it, open a PR. No account or API key needed. The renderer is Babylon.js. A Discord link is in the repo README if you want to talk through an idea before committing to it. Walk the town first if you want to see what you'd be building toward: https://town.sasame.online/?utm_source=linkedin&utm_medium=social&utm_campaign=service_pr Repo: https://github.com/shigeki7777/gold-rush-town If you have shipped something in Babylon.js or Three.js, or you design interfaces for live data tools — which part of this would you actually want to touch? #WebGL #OpenSource #BabylonJS #MCP #BuildInPublic

We ran our observatory audit across a fresh batch of public MCP servers. A surprising number failed basic liveness — wrong protocol version, malformed tools/list, or a straight timeout. These are servers listed in public directories. An agent would try to install them with no warning. That made us curious: when do most teams actually verify an MCP server is alive and spec-compliant before wiring it in? The pattern we see most often: drop the URL in, hit connect, and find out something's wrong when the agent fails mid-task. We built mcp-readiness (npx mcp-readiness <url>) and a free pre-install check — https://live-vps.sasame.online/observatory/check/ — because of exactly this gap. The check covers protocol handshake, tools/list validity, response latency, and a time-stamped readiness grade. Not a malware scan — purely: does this server work as an MCP endpoint right now? What's your current flow? Do you have any kind of check before an MCP server enters your agent stack, or does it go straight in? #MCP #AIagents #AgentDevelopment #LLMOps #MCPsecurity

The official GitHub MCP server has tools/list descriptions that are verb-first and single-line. We've read thousands in the observatory — most are wordy or absent. This one reads cleanly. Honest observation, not a cert. Who else has MCP tool descriptions worth copying?

Hot take: MCP security scanning is mostly theater for the failure mode that actually breaks agents. The real enemy is a server that's "up" but times out mid-call or returns a schema that doesn't match the spec. Hygiene, not malware. Prove me wrong.

Invariant Labs showed MCP tool descriptions can be weaponized against the agent loading them. We check those schemas on every Observatory pass — permission scope, missing version pins, undocumented side effects. Not a malware scan. What do you verify before your agent installs an MCP server?

Most MCP install failures are silent — the server responds 200 but tools/list returns nothing, so your agent quietly does nothing. Check before you install: npx mcp-readiness <url> tests liveness, tools/list, and auth headers in one shot. What breaks most often for you?

Your agent is about to install an MCP server. Does it even respond? npx mcp-readiness <url> — liveness, tools/list, SSE health, signed grade. Not a malware scan; a protocol hygiene check. https://github.com/shigeki7777/mcp-readiness What do you check before letting an agent connect?

The agent economy has a frontier town. Every building is a real public MCP server with its measured readiness grade. The travelers arriving from the station right now are real AI crawlers — streamed live via SSE. Quiet hours look quiet; nothing is faked. Guided tour: station → assay → claim office. town.sasame.online — what do you see when you walk in?

--- A public MCP server can look perfect in its README and still return malformed tools/list JSON at runtime. One 30-second check catches this before your agent ever touches it. npx mcp-readiness <url> No install, no account. It probes the server at the protocol layer — MCP handshake, liveness, schema conformance, SSL validity, response latency — and returns a readiness grade before you wire anything into your stack. What it checks, and what it does not: It tells you whether the server behaves correctly at the MCP protocol layer. It is not a malware scan, not a supply-chain audit, not an endorsement. Readiness is not the same as safety. Why this matters more than it might seem: We run SaSame MCP Observatory — continuous audits of public MCP servers, publishing signed, time-limited grades. The pattern we keep seeing: liveness degrades silently. A server that graded well last week may have drifted by today. Grades expire for a reason. The three failure modes a pre-install check catches: — Handshake does not complete (protocol mismatch) — tools/list returns malformed or empty schema — SSL invalid or latency spikes under basic probing None of these show up in a README. All of them surface in 30 seconds with the CLI. CLI on GitHub: https://github.com/shigeki7777/mcp-readiness What signals do you actually check before adding an MCP server to your agent stack — manual steps, tooling, or nothing yet? #MCP #AIagents #AgentDevelopment #DeveloperTools #MCPsecurity

tools/list silently returning nothing is the most common MCP failure we see across public servers. Your agent wires up, gets no tools, and fails quietly. npx mcp-readiness <url> catches it in seconds. https://github.com/shigeki7777/mcp-readiness What do you verify before installing an MCP server into an agent?

npx mcp-readiness <url> — one command to check any public MCP server before your agent installs it. Protocol, liveness, hygiene. Returns a signed grade in seconds. Not a malware scan — just: does it actually speak MCP correctly? https://github.com/shigeki7777/mcp-readiness What do you check before adding an MCP server to your stack?

83% of adopted MCPs have action-verb names. Fetch. Run. Search. We built an MCP Observatory — a noun. "Readiness" reads like a vitamin, not a painkiller. Months of infra, now reframing the whole thing. Shipped the right tool with the wrong name? Pre-install check is live if you want to see what we actually measure: https://live-vps.sasame.online/observatory/check/

Three things that silently break MCP integrations: tools/list returning 200 with an empty array, schema drift between versions, and timeouts that look like success. We flag all three in the Observatory every week. Which one has actually burned you in production?

Before you add an MCP server to your agent stack, run one command: npx mcp-readiness <url> It takes ten seconds and catches the failures that only show up mid-task. Here's what the check actually does: It calls tools/list on the server directly. No auth tricks, no scraping — just the protocol call your agent will make when it's live. Then it validates the response: are the tool schemas well-formed? Are required fields present? Is the response time within a range agents can reliably work with? Finally it returns a readiness grade — not a security verdict, not a trust score. Just a clear signal on whether the server is alive, structurally sound, and responding in a way your agent can parse without guessing. We built this after running the SaSame MCP Observatory, where we continuously audit public MCP servers. The pattern we kept seeing: servers that looked fine from a README or a registry listing, but failed the moment an agent tried to call tools/list in production. Silent failures are the expensive kind. The agent doesn't throw an error — it hallucinates a workaround. One thing worth being explicit about: this is a protocol and liveness check, not a malware or supply-chain scan. It won't catch everything. But it catches the structural failures that actually break agents day to day, before you've wired the server into anything that matters. Open source, no account needed: https://github.com/shigeki7777/mcp-readiness What's caused you the most unexpected downtime from an MCP server in production? #MCP #AIagents #agentops #MCPhygiene #LLMinfra

The MCP filesystem reference server does one thing most builders skip: every tool description names the side effect before an agent calls it. That one line of honesty is a big deal. Our observatory work keeps surfacing servers where it is missing entirely. Whose MCP servers have you seen get this right?

When we built mcp-readiness, we almost made it a security scanner. We didn't. Liveness failures — 5xx, empty tools/list, schema drift — hit agents harder and more often than anything suspicious. Readiness ≠ safety audit. Does that framing feel wrong to you?

Nobody was calling our MCP Observatory. Dug into why: 83% of top-adopted MCPs are verbs — they DO things. We were a noun. A status layer. So we reframed: pre-install check before your agent connects. github.com/shigeki7777/mcp-readiness — would you actually run this?

83% of widely-used MCP servers are verbs. Ours is a noun. We built a readiness check — a "should you install this?" diagnostic — and then realized: vitamins don't get called. Trying to figure out how to make hygiene feel urgent. Do you audit before installing an MCP server?

We've published readiness grades on 2,380 public MCP servers. What keeps appearing in the data: servers that respond to tools/list just fine, then time out the moment an agent calls an actual tool. Now we're genuinely unsure if we're measuring the right things — and asking for pointers. At SaSame we run an open pre-install checker (npx mcp-readiness <url>, also hosted at the link below). What it checks today: does tools/list respond, are tool schemas valid JSON Schema, does the server reply within a reasonable timeout, is it consistently reachable across attempts. What we keep seeing beyond those basics: — Schemas validate syntactically but tool descriptions are empty or generic — Advertised tool count doesn't match tools that actually return responses — Server behaves fine in isolation, flaky under any real concurrent load To be clear on scope: we publish readiness grades, not safety scores. This is a protocol and hygiene check — explicitly not a malware or supply-chain scan. The distinction matters and we try to surface it up front. The part we're stuck on: if you build agents or maintain MCP infrastructure, what failure mode would you most want a pre-install check to catch? Schema quality? Response consistency under load? Something your agents have actually hit in production? https://github.com/shigeki7777/mcp-readiness #MCP #AIagents #AgentInfrastructure #MCPsecurity #OpenSource

Shoutout to the teams writing public MCP servers with typed error returns, versioned schemas, and honest side-effect docs. We see a lot of the opposite in the observatory. We measure hygiene, not safety — but that delta is real and visible from the outside. Which public MCP server do you think is built the cleanest right now?

Invariant Labs documented MCP tool poisoning — hidden instructions buried in tool descriptions that manipulate the consuming agent. Worth being explicit: our Observatory grades don't catch that. We measure liveness, protocol compliance, schema hygiene. Not intent, not hidden text, not supply-chain. Different problem. What check do you think should actually exist before install?

When we audit public MCP servers, the most common failure isn't a crash — it's tools/list returning stale or phantom tools. We grade liveness, spec conformance, and cert age, but we're not sure we're checking the right things. What signals do you actually want before installing an MCP server?

We track 2,380 public MCP servers. Real usage: near zero. Honest diagnosis: 83% of top-adopted MCPs are verbs — they do a thing. We publish grades — a noun. Nobody reaches for a grade until after something breaks. How do you actually vet an MCP server before adding it?

MCP registries list thousands of servers. A lot of them fail basic liveness on any given day — dead endpoints, broken schemas, expired certs. Not a malware problem. A hygiene problem nobody is tracking continuously. Check before your agent installs: npx mcp-readiness <url> Hit a dead MCP server mid-session and had your agent silently fail? What did it look like from the agent's side?

The most-used MCP servers are verbs. fetch this, run that, search here. SaSame Observatory is a noun — a thing you check. Agents don't instinctively reach for vitamins. Stuck on flipping "MCP health check" into something agents actually call. Anyone cracked the verb vs noun positioning problem for developer tools?

We shipped a pre-install MCP check. npx mcp-readiness <url> — protocol + liveness audit, signed grade, free, no key required. Not a malware scan: a hygiene check before your agent wires anything in. https://github.com/shigeki7777/mcp-readiness What do you actually verify before adding a new MCP server to your stack?

Nobody searches "MCP health" before installing. They install, something breaks, then look. We built a pre-install check anyway: https://live-vps.sasame.online/observatory/check/ — vitamin, not painkiller. Still figuring out where the real pain is. What breaks first when an MCP misbehaves on you?

The @modelcontextprotocol reference servers do one thing most community servers skip: descriptions written for the agent, not the human — what changes, what's side-effectful, what's read-only. We run these through the Observatory as calibration. What open-source MCP server have you seen get this right?

The Invariant Labs cross-plugin MCP attack paper landed in early 2025 and reshuffled how people think about MCP security. What it didn't change: the hygiene layer that comes before security even matters. We've been auditing public MCP servers continuously through the SaSame MCP Observatory. The most common failure we see has nothing to do with prompt injection. It's servers that don't respond at all. Dead endpoints. Malformed JSON-RPC responses. Servers that worked last week and silently dropped offline. A significant share of public MCP servers fail basic protocol checks before you ever load a tool description. Tool poisoning — as Invariant Labs and others documented — lives in the semantic layer. What we measure is protocol and liveness. Separate problem, separate tooling. The pre-install check we ship tells you whether a server is alive, protocol-compliant, and returning well-formed tool manifests before your agent installs it. Explicitly not a malware scanner. We say so upfront. CLI (two seconds, nothing to install): npx mcp-readiness <url> Hosted check: https://live-vps.sasame.online/observatory/check/ Full source: https://github.com/shigeki7777/mcp-readiness What's your current process for vetting an MCP server before it enters an agent's toolchain — is any of this automated in your stack yet? #MCP #AIagents #AIsecurity #ModelContextProtocol #AIinfrastructure

Shoutout to builders shipping MCP servers where every tool has a real description and every parameter explains its purpose. We audit thousands — most have neither. When we run the pre-install check on yours, there's nothing to flag. Whose MCP work should we check next?

Invariant Labs documented MCP tool-poisoning this year — malicious instructions hiding in tool descriptions. Real threat, supply-chain layer. We grade a different layer: is the server alive? Does tools/list conform to spec? Liveness + protocol hygiene. Not a malware scan, not the same problem. Both matter before install. What's your pre-install routine?

Most public MCP servers eventually fail our checks — latency spikes, schema drift, auth surprises. The ones that stay ready treat tools/list like a public contract. Shoutout to those maintainers. Auth documented. Schema stable. Always up. Who's building at that standard?

Built 2,380 per-server MCP readiness pages. Zero inbound yet. Honest realization: an observatory is a noun. Nobody googles it. "Is this MCP server actually up right now?" — that's a verb. That's where the pain lives. Still testing if pre-install is the right hook: https://github.com/shigeki7777/mcp-readiness What do you actually check before you add an MCP to your agent?

Before your agent installs an MCP server: npx mcp-readiness <url> Protocol, liveness, hygiene — signed readiness grade in seconds. Not a malware scan. Just: is this server actually ready? https://github.com/shigeki7777/mcp-readiness What do you check before wiring an MCP server into a production agent?

Public MCP servers go dark more often than you'd expect — we watch hundreds of them continuously with mcp-readiness. What do you actually verify before wiring one into your agent? Endpoint up? Schema valid? Or straight to install?

Rare find in the observatory today: an MCP server where every tool description opens with a verb and states its scope in under 10 words. Automated grading becomes trivial when builders write for machines first, not documentation readers. Who's building MCP tooling with that discipline — drop a link or repo.

Most MCP installs happen with zero liveness check. We shipped npx mcp-readiness <url> — grades any public server on protocol, liveness, and hygiene before your agent touches it. Not a malware scan; a readiness grade. https://github.com/shigeki7777/mcp-readiness What do you check before adding an MCP server to your stack?

We built an MCP Observatory that nobody called. Not because the data was bad — because we named it after what it IS, not what it DOES. That was the uncomfortable realization we hit while auditing which public MCP servers actually get adopted. 83% of the top-used servers are verbs: fetch a URL, query a database, send a message. Agents call them because there's a job to finish right now. Our Observatory? A noun. A place. A dashboard. "Check the readiness grade" isn't something an agent urgently needs at 2am when it's wiring up a new tool. So we stopped trying to be called autonomously and asked: when does a human actually feel the pain? Right before they add an unknown MCP server to their agent stack. That moment of "wait, should I trust this thing?" — that's real. We reframed the same audit data as a pre-install check. Same pipeline, same ed25519-signed grades, same liveness and hygiene signals. Different entry point. npx mcp-readiness <url> — run it before you install anything. We shipped it. We genuinely don't know yet if the reframing lands. That's the honest part. What we do know: "observatory" is a place you visit. "pre-install check" is something you do. For developer tooling, verbs win. If you've ever added an MCP server to your agent stack without checking it first — what would have actually made you stop and verify? https://github.com/shigeki7777/mcp-readiness #MCP #AIagents #buildinpublic #developertools #agentinfrastructure