AI Tool Listing Card Generator¶

Capability Slug: agent_tool_card Plan Tier: Command Credit Cost: 20 / 25 / 40 credits per run (varies by output type) Category: Content Creation Default output type: tool_card

Overview¶

The AI Tool Listing Card Generator is the bridge between a partner's technical tool and the structured output formats the AI ecosystem expects. AWS launched the AI Agents & Tools category in AWS Marketplace; getting listed there means producing not just a marketplace description but also tool definitions that MCP clients and AI agents can discover and invoke. This capability generates both — plus the GTM launch content — in one structured pass, then validates the output against deterministic compliance rules.

You give it your tool name, partner company, and a description. It gives you a marketplace-ready listing card, an MCP-compatible tool definition, an OpenAPI operation schema, a getting-started walkthrough, and a compliance score telling you whether the result is publish-ready.

The three output types¶

The capability has one prompt skeleton but three output modes that differ in scope and credit cost. Pick based on what you need:

Output type	Credits	What it produces	When to use it
`tool_card` (default)	25	Listing card: metadata, capabilities, GTM content (short/full description, highlights, use cases, getting-started)	First listing pass — getting the tool into the AWS Marketplace AI Agents & Tools category
`agent_schema`	20	Tool definitions only: MCP-compatible tool definition, input/output JSON Schemas, integration metadata, example invocations	Adding agent-discoverability to an existing listing — or publishing to MCP clients without changing the marketplace listing
`resource_bundle`	40	Full launch kit: everything from `tool_card` + `agent_schema` plus support/documentation/demo URL slots	Day-one launch — partners shipping a new tool who need the complete asset set in one run

All three return a persisted AgentToolCard record so you can iterate without re-paying credits.

What gets generated¶

For every run you get back:

Field	Description
`tool_card_id`	The persisted `AgentToolCard` row. Reference it later to revise or re-validate.
`tool_card`	The structured schema for the requested output type — the data your downstream tooling consumes.
`tool_card_markdown`	Human-readable Markdown rendering of the schema.
`compliance`	`overall_score` (0-100), `overall_status` (`passed` / `needs_review` / `failed`), and a per-rule check list with severity and recommendation.
`mcp_tool_definition`	(agent_schema and resource_bundle only) Standalone MCP tool definition ready to drop into an MCP server registration.
`openapi_operations`	(agent_schema and resource_bundle only) Standalone OpenAPI 3 operation schemas ready to merge into your API spec.

What goes into the schema¶

Every output type produces some subset of these top-level blocks:

`tool_metadata`¶

name, slug (snake_case), tagline, description, category,
subcategory, partner_company, aws_services, pricing_model

Categories: ai_agent, ai_tool, ai_framework, ai_model_service
Pricing models: usage_based, subscription, free_tier, byol

`capabilities` (tool_card and resource_bundle)¶

Each capability becomes either an API endpoint or an MCP tool, with:

name, slug, description,
type (core | optional | premium),
input_type (text | json | file | image),
output_type (json | text | file | stream),
input_schema, output_schema  // resource_bundle only

`gtm_content` (tool_card and resource_bundle)¶

short_description (<= 80 chars),
full_description (<= 2000 chars),
highlights (3-5 items, <= 120 chars each),
use_cases (2-4 items with title, description, aws_services),
getting_started (numbered Markdown quickstart),
support_url, documentation_url, demo_url  // resource_bundle only

`integration` (agent_schema and resource_bundle)¶

deployment_model (saas | container | lambda | marketplace_ami),
auth_methods ([api_key, iam_role, oauth2]),
input_formats, output_formats,
protocols ([mcp, openapi, rest, grpc]),
sdk_languages, aws_integrations

`agent_schema` (agent_schema and resource_bundle)¶

tool_definition: [
  { name, description, inputSchema, outputSchema }
],
example_invocations: [
  { tool_name, description, input, expected_output }
]

The tool_definition array is what gets exported as mcp_tool_definition and openapi_operations in the response, so an MCP client or AI agent can invoke your tool directly without you re-modeling the schemas.

The compliance checker¶

After generation, nine deterministic rules score the output against listing requirements (max 100 points):

Rule	Points	Severity	Checks
`short_description_length`	10	error	`<= 80` chars
`full_description_length`	10	error	`<= 2000` chars
`highlights_count`	10	warning	3-5 items
`capabilities_defined`	15	error	At least one capability present
`use_cases_present`	10	warning	At least 2 use cases
`getting_started`	10	warning	Quickstart Markdown present
`agent_schema_defined`	15	info	At least one tool_definition (relevant for agent_schema / resource_bundle)
`aws_services_referenced`	10	warning	Tool metadata lists AWS services
`example_invocations`	10	info	At least one example invocation

Status banding:

passed — overall score ≥ 80
needs_review — overall score 50-79
failed — overall score < 50

The per-rule recommendation tells you exactly what to add or shorten if a rule fails.

Required and optional parameters¶

Parameter	Required	Description
`tool_name`	Yes	The product/tool name
`partner_company`	Yes	Your company name — drives ownership labeling and brand voice
`tool_description`	Yes	A free-form description of what the tool does — the model expands this into the full schema
`output_type`	No	`tool_card` (default), `agent_schema`, or `resource_bundle`
`category`	No	Defaults to `ai_tool`. One of `ai_agent`, `ai_tool`, `ai_framework`, `ai_model_service`
`aws_services`	No	Array of AWS services the tool integrates with (e.g. `["Amazon Bedrock", "AWS Lambda"]`)
`protocols`	No	Array of supported protocols. Defaults to `REST`. Options include `mcp`, `openapi`, `rest`, `grpc`
`pricing_model`	No	Defaults to `usage_based`. One of `usage_based`, `subscription`, `free_tier`, `byol`
`custom_instructions`	No	Free-form additional instructions appended to the prompt
`use_knowledge_base`	No	Defaults to `true`; set to `false` to skip the partner-context KB query

Knowledge base integration¶

If your agent has query_knowledge_base enabled, the capability runs a similarity search keyed to your tool name and partner company before generation:

query: "{partner_company} {tool_name} AI tool agent capabilities integration"
top_results: 3
min_similarity: 0.7

The top matches get woven into the prompt so the generated capabilities, use cases, and integration details reflect your real product. If no results meet the threshold, the run continues without KB context. Pass use_knowledge_base: false to opt out for a single run.

When to use it¶

Scenario	Recommended output type
First-time listing in AWS AI Agents & Tools category	`tool_card`
Adding MCP discoverability to an existing tool	`agent_schema`
Day-one launch of a new tool with full GTM kit	`resource_bundle`
Iterating on listing copy after editorial review	`tool_card` (re-run; the compliance score tells you what to fix)
Generating tool definitions to feed an MCP server registration	`agent_schema` (use the `mcp_tool_definition` export)
Generating OpenAPI specs for an SDK generator	`agent_schema` or `resource_bundle` (use the `openapi_operations` export)

It is not:

A marketplace publishing pipeline. The output is publish-ready content; submission to AWS Marketplace happens through the AWS console or your existing listing flow.
A general-purpose listing generator. For non-AI-tools listings, see Marketplace Listing Optimizer (marketplace_listing_optimizer).
A working MCP server. The exported mcp_tool_definition defines the interface; you still implement the tool handler.

Example flow¶

Pick your output type. Most partners start with tool_card for the first listing pass, then run agent_schema separately when they're ready to publish to MCP. Choose resource_bundle if you want everything in one go.
Run the capability. Navigate to Content Creation → AI Tool Card Generator, fill in tool name / partner company / description, list the AWS services and protocols, set the pricing model, and submit.
Read the compliance report first. If overall_status is passed, the result is ready. If needs_review, the per-rule recommendations tell you what to tighten.
Pull the agent exports if you ran agent_schema or resource_bundle. The mcp_tool_definition and openapi_operations keys are formatted for direct copy into an MCP server registration or an OpenAPI spec.
Iterate from the saved record. The tool_card_id lets you re-run validation after edits without re-paying credits.

API access¶

The capability is exposed through the agent runtime as agent_tool_card. Partner API keys scoped with manage_content plus the agent capability slug can generate tool cards programmatically through the agent execution endpoint. Responses include the persistent tool_card_id so you can fetch and update the record through your own integration. See Partner API Capabilities and Authentication & API Keys.