Plugins, connectors, and skills

Connected tools, an open notebook, and document cards arranged on a warmly lit workbench.

Build with AI · Sources reviewed 2026-11-19

An assistant becomes more useful when it can work with the right information and produce something you can use. A project brief can draw on approved notes. A support assistant can retrieve the relevant runbook. A document workflow can turn a file into fields that another application understands.

The useful question is what each added component contributes. A package name alone tells you little about its access, instructions, or actions.

On this page
An application authorizes retrieval of project notes. The notes and reusable instructions inform a model, whose proposed brief returns to application validation before a separate save operation.
Retrieval and saving are separate tool operations. The two application boxes show successive responsibilities of the same application; reusable instructions describe the method without granting access. Diagram: Root Access Guy.

Follow one job through the layers

Imagine a fictional design studio preparing a client project brief. It wants a draft assembled from approved project notes, with missing decisions clearly marked. It needs several distinct capabilities:

Piece Its job in this example What to inspect
Model Interpret the notes and propose the brief Whether the output preserves facts and uncertainty
Skill or reusable instructions Define the studio’s drafting method Trigger, procedure, examples, resources, and maintenance
Connector Provide a supported route to the notes application Account, source scope, read/write operations, and data handling
Tool Perform a named operation, such as fetching a project Arguments, authorization, returned evidence, and errors
Plugin or extension Package capabilities for an application Publisher, bundled components, updates, and requested access
Workflow Organize retrieval, drafting, checking, and saving Triggers, conditions, review points, and failure paths
Application Enforce identity and execute permitted operations Validation, secrets, logs, and recovery

Names differ between products. Inspect the installed component and the current documentation. A platform may call a connection an app, an integration, or an extension.

Anthropic’s Skills documentation describes one concrete approach: a package containing instructions and metadata, with optional scripts and supporting resources. That format illustrates how a reusable procedure can travel with its working materials. Adoption and execution support still depend on the host application.

Build a reusable project-brief skill

Start with a procedure you could hand to a colleague. Give it a narrow purpose and a clear deliverable. This example is a platform-neutral instruction template; adapt packaging to the host’s documented format.

Name: Project brief preparation
Use when: A team member requests a draft from approved project notes.
Inputs: Project ID, current notes, source version, requested deliverables.
Procedure:
1. Record the project ID and source version.
2. Extract objectives, deliverables, dates, owners, and open decisions.
3. Preserve explicit facts; mark absent information as unknown.
4. Build the brief using those fields and cite the source sections.
5. List conflicts and questions for the project owner.
Output: Draft brief plus a source and open-questions table.
Completion: A reviewable draft exists; delivery to a client is separate.

For a first attempt, paste fictional notes into an assistant and use these instructions. You can learn whether the procedure works before connecting anything.

Then add a sample input: “Project P-104: create three landing-page concepts. Owner: Lena. Review on 12 December. Launch date undecided.” A useful output preserves three concepts, identifies Lena, and leaves the launch date unknown. It should ask which year applies to the review date if the surrounding project context does not establish it.

Connect only the information the job needs

An API is a defined interface through which software requests information or actions. A connector adapts that interface for the application using it. A webhook is an event notification that can start work when something changes. Authentication establishes the caller’s identity; authorization decides which resources and operations that identity may use.

For the studio, a practical sequence is:

  1. Create a test project containing only fictional notes.
  2. Choose a connector that can retrieve that project and inspect its operations.
  3. Establish the account and source boundary in the application.
  4. Fetch the notes and retain their identifier and version.
  5. Run the reusable drafting procedure.
  6. Save the reviewed output through a separately defined operation.

The permission model matters. For example, Microsoft Graph distinguishes delegated access from application access. A background service and an application acting with a signed-in user can have different effective access. Check the actual API and tenant configuration before assuming a connector follows the requester’s permissions.

Keep credentials in the platform’s connection or secret-management mechanism. A prompt should receive the task information it needs, not the secret used to retrieve it.

Give tools a clear contract

A useful retrieval tool returns enough information to judge what happened. Here is an illustrative application contract, not an API copied from a vendor:

{
  "tool": "read_project_notes",
  "arguments": {"project_id": "P-104"},
  "result": {
    "status": "ok",
    "source_id": "notes-P-104",
    "version": 7,
    "text": "Three landing-page concepts. Launch date undecided."
  }
}

The application derives the user’s access from the authenticated session. It checks access to P-104 before returning text. A tool error should state whether the source was unavailable, the request was invalid, or access was denied; it should not disguise all three as an empty document.

Anthropic’s tool-design guidance emphasizes clear tool descriptions and useful returned context. Apply that idea by making the outcome and its evidence explicit.

Where MCP fits

The Model Context Protocol architecture describes a common interface between AI applications and programs exposing capabilities. Its building blocks include tools, resources, and prompts. A host can use those capabilities while retaining responsibility for its own application behavior.

MCP can make integration reusable across compatible hosts. It does not decide which business information a person should see, automatically make every integration portable, or replace the destination service’s authorization. Check the host, server, supported protocol version, transport, and actual operations together.

Keep knowledge, memory, and training distinct

Mechanism What changes Example
Instructions The task guidance supplied to the system The studio’s brief-writing procedure
Retrieval Which source material enters a particular request Fetching version 7 of project notes
Context Information available during the current model call Request, instructions, retrieved notes, and tool results
Persistent state Records retained between steps or sessions A saved draft ID and pending questions
Fine-tuning Model parameters through a training process A separately evaluated adaptation for a defined task

Uploading a document to a retrieval collection does not itself demonstrate that a model was trained on it. Data retention and training use are separate product and contractual questions. Read the terms for the particular service and account.

Choose the smallest workable installation

A hosted connector can reduce infrastructure work while adding vendor and subscription dependencies. A local integration offers more control over its runtime and still needs maintenance, updates, access rules, and backups. A hybrid setup can retain source systems locally while using a hosted model; inspect precisely which content crosses that boundary.

Budget for subscriptions, model usage, connector operations, storage, and the time spent correcting outputs. Test missing notes, a revoked account, a conflicting date, and a request for an unauthorized project. The draft should expose the problem and stop the affected step.

Next, turn this component map into a repeatable workflow, or follow the approved-knowledge build.

Keep building

Next guide: Inside an AI agent

Explore Build with AI

Share this page