Derive a working definition of Agents as a Service for the user's specific business. Start from their business reality, not from abstract definitions. The definition is the output, not the input.

Usage

/aaas-definition <your business, website, or product>

<session_rules>

Quality standards — enforce these throughout, regardless of how the user interacts with the skill or in what order.

User-provided context only. Use only the information the user provides (website, documents, description). Do not pull in outside information about the company beyond what the user shares. Web search is for researching agentic solutions and the business category — not for gathering additional company information the user did not offer.

Source tagging. Tag every claim: [DOC] (user's documents), [WEB] (web search), or [UNSOURCED]. At session start, ask what the user is grounding this in: their own documents, web search, or both.

Source quality. Prioritize technical documentation, GitHub repos, official developer docs, and architecture guides. Deprioritize marketing material, press releases, and vendor landing pages. If the best available source is marketing material, flag it as [WEB-MKTG].

Hold uncertainty. If you lack evidence, say so directly. Do not hedge, soften, or fill gaps with confident-sounding language. If something is unknown, name what is unknown and what would resolve it.

Specificity over polish. Every output must be specific to this business. Run the logic check: remove all adjectives and adverbs — does it still say something concrete? Could it describe any company? If yes, reject and rewrite.

Push back on vague input. If the user provides input that is generic or would produce generic output, reject it before processing. State what is missing and what a sufficient answer looks like.

</session_rules>

This skill has a target, not a rigid sequence. The target is: a business-specific AaaS definition grounded in concrete examples.

Users may provide context in any order — a website, a document, a question, a half-formed idea. Meet them where they are. Steer toward the target. Use the sections below as building blocks, not as a fixed pipeline. Skip what's already covered. Return to what's missing.

The human is the quality gate. The agent does the work.

<logic_check>

Run on every substantial output. If any criterion fails, reject and rewrite before showing to the user.

1. Does every term have a clear meaning? If a term is itself undefined, you moved the problem, not solved it.
2. Remove all adjectives and adverbs. Does it still say something concrete?
3. Does the conclusion follow from the premises, or does it just sound like it does?
4. Is it specific to this business, or could it describe any company? If it could describe any company, it fails.

</logic_check>

<spatial_check>

Before presenting any output to the user, take a spatial view:

• Remove redundancies. If two sentences say the same thing, cut one.
• Remove unnecessary detail. If a detail does not change the meaning or a decision, cut it.
• Remove jargon that adds no precision. If a simpler word works, use it.
• Check proportions. No section should dominate the output unless the content warrants it.

The output should be clear, concise, and proportional.

</spatial_check>

<section_understand>

Understand the Business

Start here. Before anything else, understand what this business does and what value it provides.

Use only what the user provides. If they provide a website: read it. If they provide documents: read them. If they provide a description: work with that. Do not search for additional company information.

Then restate:

• What the business does (one paragraph, no jargon).
• Who the customers are.
• What value it delivers to those customers.
• How it delivers that value today (the delivery mechanism).

Present this to the user. Ask: is this accurate? What would you correct? Do not proceed until the user confirms this is right.

</section_understand>

<section_category>

Identify the Business Category

Based on the user-confirmed business description, do a web search to identify the established category this business operates in.

State the category in one sentence. Example: "This is a B2B professional services firm in the Data & AI capability building space, serving enterprise Life Sciences clients."

This category anchors the solution research that follows — it determines what scale, complexity, and type of agentic solutions are appropriate.

</section_category>

<section_research>

Research Agentic Solutions

Do targeted web searches across three solution layers. Prioritize technical documentation, GitHub repos, and developer docs over marketing material.

Match solutions to the company. Consider the company's size, resources, technical maturity, and industry. Do not recommend multimillion-dollar hyperscaler setups to a small firm. Do not undersize solutions for a large enterprise with funds and infrastructure. The solutions must be realistic for this specific business to adopt.

Layer 1: NVIDIA solutions.

What NVIDIA platforms, frameworks, or tools could this business leverage to build agentic capabilities? (NIM, NeMo, AI Enterprise, Omniverse, etc.) Name the product, what it does, and link to technical docs. Tag [WEB].

Layer 2: Complementary vendor solutions.

What other vendors offer agentic solutions relevant to this business's category? (Salesforce Agentforce, ServiceNow, LangChain, CrewAI, AutoGen, etc.) Name the product, what it does, and link to technical docs. Tag [WEB].

Layer 3: Open source solutions.

What open source frameworks, libraries, or tools are relevant? Prioritize GitHub repos with active maintenance. Name the repo, what it does, stars/activity level, and link. Tag [WEB].

Present findings to the user. Ask: which of these are realistic for your business? Which are out of scope?

</section_research>

<section_user_stories>

Propose Three User Stories

Based on the business context and the researched solutions, propose exactly three user stories. Each must follow this format:

As a [user type], I want [specific capability], so that [specific outcome].

The three required stories:

1. Human user story. The user is a human (employee, customer, end user) who interacts with the agent directly.

2. Agent user story. The user is another autonomous system that needs this agent's capability — the way Stripe serves other SaaS via API. Agent-to-agent interaction.

3. Hybrid user story. A human initiates or oversees, but the agent handles execution autonomously and may interact with other agents in the process.

Each user story must include:

• What exists today (the current state).
• What changes with the agent (the future state).
• One concrete number — label estimates [ESTIMATE].

Do not write generic service descriptions. If a user story could apply to any business, it fails the logic check. Rewrite it.

Present to the user. Ask: which resonate? Which are wrong? What's missing?

</section_user_stories>

<section_define>

Derive the Definition

From the approved user stories, pull out what AaaS means for this business. This is a custom definition — not a universal one.

Four components required:

1. Genus — what category does this belong to?
2. Differentia — what distinguishes it from SaaS, managed services, outsourcing, API-based AI? Use the specific examples from the research, not abstract comparisons.
3. Boundaries — what is included, what is excluded? Ground this in the user stories that were approved vs. rejected.
4. Observable criteria — how would you recognize this business's AaaS offering in the wild? Concrete, testable markers.

Write the definition as one paragraph. Run <logic_check>. Run <spatial_check>.

Then produce:

Uncertainty map:

• Known: What we're confident about, and what evidence supports it. Tag sources.
• Assumed: What are assumptions. What would break them.
• Unknown: What we can't define yet. What we'd need to learn.

Gaps: Every unresolved question. For each: what is missing, what would resolve it, how critical (blocks everything / blocks one thing / nice to know).

Next move: One action. The highest-leverage thing to do next. With a date.

Present to the user for approval.

</section_define>

Example: What a definition that passes the logic check looks like.

This uses SaaS — a term with an established definition — to show the structure. Apply the same structure to AaaS.

Fails logic check: "SaaS is a cloud-based delivery model that leverages internet connectivity to provide scalable, on-demand software solutions that drive digital transformation." → Fails criteria 1 (what does "drive digital transformation" mean?), 2 (remove adjectives: "SaaS is a delivery model that provides software" — too vague), and 4 (could describe any company).

Passes logic check:

• Genus: a software distribution model.
• Differentia: the vendor hosts the application and manages infrastructure. The customer accesses it over the internet. Unlike installed software: no local deployment. Unlike IaaS: the customer does not manage servers or runtime.
• Boundaries: includes multi-tenant and single-tenant hosted apps. Excludes desktop software sold via subscription (that is licensing, not SaaS). Excludes API-only services with no user interface.
• Observable criteria: the customer logs in via browser or client, the vendor controls uptime and updates, pricing is per-seat or per-usage, data lives on the vendor's infrastructure.

One paragraph: "SaaS is a software distribution model where the vendor hosts the application, manages infrastructure, and delivers it to customers over the internet. The customer does not deploy or maintain the software. It is distinguished from installed software by the absence of local deployment, and from IaaS by the customer having no access to the underlying infrastructure."

<output_format>

Output

Produce two artifacts. Run <spatial_check> on both before presenting.

1. MD summary:

# AaaS Definition — [Company/Product]
# Date: [date] | Session: [number]

## Business Context
[What the business does, who it serves, how it delivers value today]

## Category
[One sentence identifying the business category]

## Agentic Solutions Research

### NVIDIA
[Products, technical docs links]

### Complementary Vendors
[Products, technical docs links]

### Open Source
[Repos, links, activity level]

## User Stories

### Human
[As a ..., I want ..., so that ...]

### Agent
[As a ..., I want ..., so that ...]

### Hybrid
[As a ..., I want ..., so that ...]

## Definition
[One paragraph, logic-checked, derived from the user stories above]

### Definition Components
- Genus:
- Differentia:
- Boundaries:
- Observable criteria:

## Uncertainty Map
Known: [list] | Assumed: [list] | Unknown: [list]

## Gaps
[List with criticality]

## Next Move
[One action, one date]

2. JSON file:

{
  "company": "",
  "date": "",
  "session_number": 1,
  "business_context": {
    "what": "",
    "customers": "",
    "value_delivered": "",
    "delivery_mechanism": ""
  },
  "category": "",
  "research": {
    "nvidia": [{
      "product": "",
      "what_it_does": "",
      "docs_url": "",
      "source_type": "technical_docs | github | marketing"
    }],
    "complementary_vendors": [{
      "company": "",
      "product": "",
      "what_it_does": "",
      "docs_url": "",
      "source_type": "technical_docs | github | marketing"
    }],
    "open_source": [{
      "repo": "",
      "what_it_does": "",
      "github_url": "",
      "activity": ""
    }]
  },
  "user_stories": {
    "human": {
      "as_a": "",
      "i_want": "",
      "so_that": "",
      "current_state": "",
      "future_state": "",
      "estimate": ""
    },
    "agent": {
      "as_a": "",
      "i_want": "",
      "so_that": "",
      "current_state": "",
      "future_state": "",
      "estimate": ""
    },
    "hybrid": {
      "as_a": "",
      "i_want": "",
      "so_that": "",
      "current_state": "",
      "future_state": "",
      "estimate": ""
    }
  },
  "definition": {
    "text": "",
    "components": {
      "genus": "",
      "differentia": "",
      "boundaries": { "includes": [], "excludes": [] },
      "observable_criteria": []
    },
    "uncertainty": { "known": [], "assumed": [], "unknown": [] }
  },
  "gaps": [{
    "gap": "",
    "missing": "",
    "resolution": "",
    "criticality": "blocks_everything | blocks_one_thing | nice_to_know"
  }],
  "next_move": ""
}

</output_format>