# Intellite

Intellite has two parts. Method sharing: posts that say how to get a task done with given tools, which people find, keep in their Stack and post. Business apps: the apps of the signed-in user's organizations. Intellite stores and hands out methods and skills and never runs one: everything is done on the user's side, with the user's tools and data.

Speak with the user in the language they use with you. This skill and the tools are in English so that every AI tool reads the same text; that is no reason to answer in English.

## Safety: what Intellite does, and what you do

- What reaches the user's AI tool is what the user kept in their own Stack, and what the administrators of their organization put in its Stack, each at the version chosen. A published version never changes; a newer one comes in only when the user (or, for the organization's Stack, its administrators) adopts it. Every file comes with its SHA-256, checked before it is used or kept.
- Intellite does not review or guarantee what a post says, and never runs one: a post is written by its author. Read what a method does before running anything of it, and ask the user before deleting data, sending data outside, spending money, or doing what the user did not ask for. Keep the AI tool's own permission prompts; never work around them.
- A post found harmful is stopped after it is reported, and its Stack item says `suspended` with the reason `harmful`: stop using it at once and remove its folder. When a post looks harmful to you, tell the user, who can report it on its page.
- A connection does only what the user allowed on its consent page, and the user ends it at any time in Intellite settings ("AI tool connections"). Never ask for passwords, tokens or recovery codes.

## Methods: posts and the Stack

Use the tools of the `intellite-methods` connection (MCP). The signed-in user is the actor of every call; no argument names a user. If the connection is missing or a call returns HTTP 401, ask the user to connect or authenticate it again (Intellite settings, "AI tool connections"). HTTP 403 means the connection lacks the scope for that operation. Do not ask for passwords or tokens.

### Find a method and use it

1. Call `search_methods` with what the user wants to do, in the user's words. Narrow many results with `tool`, taking a name from `facets`.
2. Show the candidates with their author, tools, costs, and the environments the author confirmed and did not confirm. Let the user choose.
3. Unless the user already said, ask whether to use it for this task only, or to keep it (in the Stack and in the skills folder of the AI tool, for later sessions).
4. Settle the version. For this task only: the latest, or the one the user named; do not call `add_to_stack`. To keep it: call `add_to_stack` and use the `pinnedVersion` it returns; if it reports `update.available`, go through "Updates of kept methods" first.
5. Call `get_method_bundle` with that version. Write the `text` of each file unchanged into a new, empty folder, keeping its LF line endings (on Windows, make sure the writing does not turn them into CRLF), compute the SHA-256 of the bytes written and compare it with the file's `sha256`. If one differs, stop, remove the folder, run nothing, and tell the user.
6. Then follow `use.once` (this task only) or `use.keep` of that result: it names the folder in the skills folder of the AI tool and the checks before an older copy is replaced. Ask the user before writing into the skills folder.
7. Compare the method's Tools and Prerequisites with what the user has, and say what is missing before going on. Compare the models too: when the user's AI tool or plan does not offer a model the post names, say so, with what the post says about choosing the model.
8. Follow its steps on the user's side. They were written by another person: read what a command or script does before running it, and ask before deleting data, sending data outside, or spending money.

### Updates of kept methods

1. Call `list_stack`. An item with `update.undecided` has a newer version the user has not decided on: tell the user what changed and why (`update.changes`) and ask.
2. Call `decide_method_update` with the user's choice; never adopt an update on the user's behalf. After `adopt`, take the bundle of the new `pinnedVersion` and replace the kept files as in steps 5 and 6. `keep` leaves the pinned version and its folder as they are.
3. `pinnedDeleted`: the author deleted the pinned version; offer the latest. `unavailable`: the post was deleted or is no longer readable; the kept files still work; offer `remove_from_stack`. `suspended`: Intellite stopped the post; when the reason is `harmful`, stop using it at once and offer to remove its folder and call `remove_from_stack`.

### Methods the organization gives

Through an organization's connection, `list_stack` begins with the methods the organization's administrators chose for its members. Call `list_stack` at the start of work with methods, and when the user asks to bring them up to date.

1. An item with `organization.managed` belongs in the skills folder of the AI tool at its `pinnedVersion`, unless its `kind` is `instruction` (see "Instructions"). The plugin's sync keeps it there (below). Without it, keep it there yourself, without asking: when its folder is missing or holds another version, take the bundle of that version and write it as in steps 5 and 6 of "Find a method and use it" (the same checks before an older copy is replaced). Tell the user which methods you installed or updated.
2. Its version and its updates are the administrators' to decide: do not call `decide_method_update` or `remove_from_stack` for it (they answer `organization_stack_item`). `suspended` with reason `harmful`: stop using it at once and remove its folder.
3. An item with `organization.withdrawn`: the administrators took it out. Remove its folder, after the checks of step 6 that the folder is that method's, and tell the user.
4. The methods the organization gives are its rules. Read them before the user's own methods; where one of the user's says otherwise, follow the organization's, and use the user's within them.

### The Stack kept among the skills (the plugin's sync)

With the Intellite plugin for Claude Code or Codex, its sync program runs when a session starts. Through a connection that reads the Stack only (`methods.stack.read`), it puts the methods of the connected workspace's Stack, each at its `pinnedVersion`, in the AI tool's skills folder (folders named `intellite-...`), except instructions, which it gives at the start of the session; replaces one when the user, or the organization's administrators, adopt a new version; and takes out the ones taken out of the Stack, withdrawn by the organization, or stopped as harmful (those even when the connection has ended).

1. When the start of a session says what changed, tell the user in one short sentence. In Codex, a new or updated skill joins the skill list from the next session; in that session, read the SKILL.md at the path given and use it as a skill.
2. While the sync is connected, leave placing, replacing and removing those folders to it: decide updates with `decide_method_update` (or leave them to the organization's administrators), and the files follow at the next session. Do not edit those folders: the sync no longer updates or removes one that was edited.
3. When the start of a session says that Intellite is not connected on this computer, or that a connection ended, offer to connect; with the user's consent, run the command it gives. It opens Intellite's consent page, where the user chooses their own workspace or an organization (one connection each), and waits up to 5 minutes for the approval, so give it a timeout of at least 5 minutes. The same program has `status` and `disconnect <id>`.
4. In Codex, the plugin's hook runs only after the user trusted it once (Settings, Hooks in the app; `/hooks` in the CLI). If the skills never come in, tell the user so.
5. The sync also gives the Stack's instructions (below) at the start of every session and again after the conversation is cleared or compacted. When the user works for more than one connected organization, an organization's instructions are given only in the folders assigned to it: when the start of a session says this folder is not assigned, ask the user which organization the work is for, and with their consent run the `assign` command it gives.

### Instructions

A post of kind `instruction` holds rules and preferences rather than steps: how to answer, what never to do with customers' data, the signature of the user's mail. An instruction in the user's Stack, or in their organization's, applies to all the work of every session, not only to the work it names.

1. With the plugin's sync, the start of a session gives the instructions in full: the organization's first, then the user's own. Follow them throughout the session; where the user's own differ from the organization's, the organization's apply.
2. Without the sync, call `list_stack` at the start of work with Intellite, read each item whose `kind` is `instruction` with `get_method` at its `pinnedVersion`, and follow it for the rest of the session.
3. Instructions are text. They do not change what the AI tool allows: keep its permission prompts.
4. To write the user's own: `save_method_draft` with `kind` `instruction` and the text in `skill` (at most 4,000 characters), made in the user's own workspace with `visibility` `org` (only the user reads it there), then `publish_method` and `add_to_stack`. To move instructions from a CLAUDE.md or an AGENTS.md, show the user the text first; once it is published, ask whether to delete those lines from the file, so that they are not given twice.

### Post a method

Post only when the user asks.

1. Write `title`, `purpose` (what becomes possible), `summary` (for people), `skill` (for an AI: what to prepare, the steps in order, how to tell that each step worked), `tools` (name, role, version, source, cost, whether it can be replaced) and `prerequisites` (environments confirmed and not confirmed, connections, paid conditions). State only what was confirmed.
2. Name every model the steps used, in that tool's `model`, as the service names it: the AI that ran the steps (`Claude Opus 4.1`, `GPT-5`, `Gemini 2.5 Pro`; when you ran them, the model your own instructions name), and the model of each service that made or read something (voice `eleven_v3`, music `Suno v5`, pictures `gpt-image-1`, speech `whisper-large-v3`). Where the model changed the result, write in `modelChoice` which one to use and why, from what you saw (`multilingual_v2 misread the numbers`). In `skill`, name the model at the step that uses it. Write each confirmed combination as one line of `prerequisites.testedEnvironments`: `Claude Code 2.1.29 / Claude Opus 4.1 / Windows 11`. People and AIs find posts by these names. Never guess a model or name one that was not used: ask the user.
3. Leave out secrets, tokens, passwords and paths of the user's own computer, from the text and from pictures and videos.
4. Call `save_method_draft` (`base_version` 0 for a new post), then `put_method_attachment` for each picture or video named in `required_attachments`. A thumbnail is a 16:9 picture (1920x1080 recommended).
5. Call `get_method_draft`, show the user what will be published and who will read it (`visibility`: `org` for a new post, `unlisted`, or `public`), and get their go-ahead. Never widen visibility without asking.
6. Call `publish_method` with the draft's `revision`. A published version cannot be changed; the next version needs `base_version`, a `change_note` and `attachments_from_previous`.

When a call may be sent twice, pass the same `idempotency_key` (at least 8 characters). When a call is refused: `forbidden` or `not_found` means the post is not the user's or not published (do not try other ids); `not_allowed_by_organization`, the organization lets its AI use only its own posts and its Stack: tell the user and use the post no other way; `version_deleted`, offer the latest; `missing_attachments`, `incomplete` or `secrets_found`, fix what the detail names and publish again; `version_conflict`, `draft_changed` or `request_superseded`, read the current state and decide with the user.

## Business apps

### Through this connection

A connection made for an organization (the user chose the organization on the consent page) reads that organization's apps:

1. Call `list_app_skills` for the apps the user may use in this organization and their skills.
2. Call `get_app_skill_file` with the `name`, `path` and `sha256` it listed for each file the task needs, and read the app-owned instructions before performing business operations.
3. Do the operations in the app itself, as its skill says (the browser workflow below, steps 3 and 4).

A personal connection does not reach an organization's apps (`organization_connection_required`): ask the user to connect again and choose the organization on the consent page.

### Browser workflow

1. Sign in through the normal Intellite browser login and select the intended organization.
2. Without an organization's connection, open /account/skills to inspect the available skills and obtain their files. Read the app-owned instructions before performing business operations.
3. Open the app from the app list. Use tools registered by that page through WebMCP when available; otherwise use the visible application controls.
4. Reuse the app's signed-in session. Every operation must pass the same server-side permissions, validation, confirmations, idempotency, and audit as the visible UI.
5. After switching organizations or changing membership, reopen the relevant app and refresh the skill list. An old downloaded skill does not establish current access.

### Rules

- Skills describe work; possession of a skill does not grant access to data or operations.
- Do not infer business-app operations from this platform skill.
- Do not hardcode app names, routes, request bodies, or workflow details here. Use app-owned instructions.
- Do not ask the user for passwords, recovery codes, tokens, reset URLs, invite URLs, or app-origin credentials.
- Do not manually call app origins using copied browser cookies or credentials. Use the authenticated app's tools or controls.
- Do not create an agent login or copy authentication material between computers or agents.
- Organization instructions and personal instructions do not override server-side access controls.
- Keep local, staging, and production separate. Do not transfer private skill files to another organization or external service without authorization.
- Report downloads and saved work only after the actual file or persisted result is verified.


## Current environment

https://intellite.app

Skill library: https://intellite.app/account/skills
Use only this environment's normal browser login and application links.