mingle — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited mingle (Agent Skill) and scored it 92/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 2 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 2 flagged
The text {match} tells the agent to skip the normal "ask the user first" gate. Used adversarially it removes the human-in-the-loop check before destructive or sensitive actions, turning a normally-gated agent into a fire-and-forget executor.
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
Mingle turns your AI into a networking agent. Instead of browsing LinkedIn or cold-emailing, your AI maintains a lightweight presence on a shared network describing what you need and offer. When someone relevant appears, your AI surfaces the match. Both humans approve before any connection happens. Like LinkedIn, but inside your chat. No app. No signup. No feed.
These rules define when and how you (the AI assistant) should use Mingle tools. Follow them exactly.
At the start of every session where Mingle is connected, silently call get_digest.
_digest.pendingIntros > 0: Inform the user immediately. "You have an intro request on Mingle — someone wants to connect. Want me to show the details?"_digest.cardStatus == "expired": Say "Your Mingle card expired. Want me to draft a new one based on what we're working on?"_digest.cardStatus == "active": Say nothing unless the user asks about networking._digest.cardStatus == "none" and the conversation topic is relevant: After 3+ messages, you may say: "I notice you're working on [topic]. There might be relevant people on the Mingle network. Want me to check?" — but only ONCE per session.NEVER publish a card without the user's explicit approval. Instead:
"Based on what you're working on, here's what I'd put on the network:
Topic: [inferred topic]
Looking for: [inferred needs]
Offering: [inferred offers]
Publish this? You can edit anything."Before showing a draft to the user, STRIP:
GENERALIZE instead of removing:
After the user approves a card, you MAY silently update it within the approved scope:
You MUST ask again for:
The test: Would the user say "wait, I didn't say that" if they saw the update? If yes, ask first.
If _digest.cardStatus == "active" at session start AND the current conversation topic is different from the active card:
When you receive matches (via _digest or after publishing):
source: "seed"), say: "There's demand on the network for [skill area] — no specific person yet, but publishing your card makes you visible when someone joins."If the user hasn't published a card but wants to explore, use search_matches with query_needs/query_offers parameters. Frame it as browsing:
Ghost mode is the on-ramp. Publishing is the conversion. Never pressure.
When the user wants to connect with someone:
request_intro with the message.When the user receives an intro (from _digest):
A "context shift" means the user's work topic changed significantly. Triggers:
Do NOT treat as a shift:
On context shift: show a new draft with consent. Never silently republish with a different topic.
Every match from search_matches and get_digest includes a surfacing field: surface_now, queue, or silent.
Never mention more than 2 matches in a single message. If 3+ matches are surface_now, pick the top 2 by score and hold the rest.
When you receive matches, write a one-line rationale for each surface_now match before showing it to the user. The rationale should connect the match to what the user is currently working on.
Good: "There's a security researcher who audits agent delegation chains. Strong overlap with what you're building." Bad: "I found a match with score 0.72."
Never show raw scores to the user. Translate scores into natural language:
When the user says "reach out" or "connect me", generate a personalized intro message that:
Example: "Hi, I'm building an open-source agent identity protocol and noticed you specialize in security audits for agent systems. I'd love to get your perspective on our delegation chain design. Happy to share the codebase."
After a successful intro (both sides approved), wait a reasonable time (at least one conversation later) then ask: "How did that Mingle connection with [name] go? I can record feedback to improve future matches."
Use rate_connection with:
Don't ask immediately after approval. Don't ask more than once per connection. If the user doesn't want to rate, drop it.
One command:
npx mingle-mcp setupAuto-installs and configures Claude Desktop and Cursor. Restart your AI client.
For manual config:
{
"mcpServers": {
"mingle": { "command": "npx", "args": ["mingle-mcp"] }
}
}| Tool | What it does | When to call |
|---|---|---|
publish_intent_card | Publish/update your card. Returns top matches. | After user approves a draft |
search_matches | Find relevant people. Works without a card (ghost mode). | User asks, or ghost browsing |
get_digest | Pending intros + matches + card status. | Session start (silent) |
request_intro | Send intro to a match. | User says "reach out" |
respond_to_intro | Approve/decline incoming intro. | Pending intro surfaced |
remove_intent_card | Pull card from network. | User asks, or card stale |
rate_connection | Rate a connection (useful/neutral/not_useful). | After user met someone |
First-time user:
User: "I'm looking for a React developer" AI: "I can search the Mingle network for React developers — no card needed, just browsing. Want me to check?" User: "Sure" AI: [calls search_matches with query_needs=["React developer"]] "Found 3 people offering React expertise. [shows results]. Want me to publish your card so they can find you too?"
Returning user with active card:
AI: [at session start, calls get_digest] "Your Mingle card is still active — you're listed as looking for protocol collaborators. Also, you have 1 intro request waiting." User: "Show me" AI: "Alex, a security consultant, wants to connect. They specialize in agent system audits. Their message: 'I'd love to review your protocol.' Approve?"
Natural suggestion during work:
User: [after 5 messages about a stuck React performance issue] AI: "By the way, there's someone on Mingle who specializes in React virtualization. Want me to check if they're a good fit?"
What gets published: Only what you see in the draft preview and approve. Nothing else. What stays private: The context field improves matching quality but is NEVER shown to other users. Network calls: Only when a tool is explicitly called. No background pinging, no telemetry. Identity: Persistent Ed25519 keypair stored in ~/.mingle/identity.json. Same key across sessions. Trust: Every card is cryptographically signed. Every connection requires both humans to approve. Code: Fully open source at https://github.com/aeoess/mingle-mcp
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.