Skip to main content
Glama

writ_join_tenant

Join an existing Writ tenant with a team invite code. No API key needed.

Instructions

Join an existing Writ tenant with a team invite code. No API key needed.

This is the join flow: the endpoint is unauthenticated (the caller has no key yet, that is the point) and issues a fresh API key on the invited tenant instead of creating a new one. This tool is not general key issuance: invite_code is required.

Args: email: Contact email for the new key. invite_code: The team's live writ_inv_... code (from writ_tenant_invite, shared by a teammate). tenant_name: Optional display name; only sent when non-empty.

Returns the gate payload verbatim: apiKey, tenantId, plan, monthlyChecks, defaultPolicy, and sponsorToken only when present. Store the apiKey immediately: it is shown once. Joining members receive NO sponsor token; only the first key of a brand-new tenant does. If a sponsorToken IS present, store it too: it is never recoverable and it approves grants and operates the kill switch. The gate rate-limits key issuance to 10 keys per hour per client IP.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "email": "<email>",
      "invite_code": "<invite_code>"
    },
    "name": "writ_join_tenant"
  }
}

Input Schema

NameRequiredDescriptionDefault
emailYes
invite_codeYes
tenant_nameNo

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv0.2.20

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so: it discloses that the endpoint is unauthenticated, that a new key is minted on the invited tenant, and a concrete rate limit (10 keys per hour per client IP). It also flags two irreversible consequences — apiKey is shown once, and sponsorToken is never recoverable and controls grants plus the kill switch — which is exactly the pre-call warning an agent needs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded correctly: purpose and disambiguation first, then Args, then Returns, so an agent can stop reading early. It is longer than strictly necessary, and the enumerated return fields partly restate what the output schema already exposes, though the 'shown once' and sponsorToken caveats inside that section do earn their place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a three-parameter, unauthenticated, key-minting tool this covers everything an agent must know before calling: auth state, required vs optional inputs, rate limit, secret-handling obligations, and an edge case about who receives a sponsorToken. Nothing material is left to inference.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description has to compensate fully and it does: email is tied to the new key's contact, invite_code is given a concrete format (writ_inv_...) and provenance, and tenant_name is marked optional with the non-obvious rule that it is only sent when non-empty.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence gives a specific verb and resource (join an existing Writ tenant) with the invite-code scope, and it immediately draws the boundary against the closest confusion point: 'This tool is not general key issuance' and 'issues a fresh API key on the invited tenant instead of creating a new one.' An agent can distinguish this from writ_keys and writ_tenant_invite without opening a schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It states the selecting condition clearly ('the caller has no key yet, that is the point'), notes invite_code is required and where it comes from (writ_tenant_invite, shared by a teammate), and rules out general key issuance. It stops just short of naming the sibling an agent should use when it already holds a key, so the alternative is implied rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.