Skip to content
| Marketplace
Sign in
Visual Studio Code>AI>thinQit CodyNew to Visual Studio Code? Get it now.
thinQit Cody

thinQit Cody

thinQit AI

|
14 installs
| (4) | Free
Your thinQit coding teammate in VS Code. Watch Cody work on the Mission Map, review every change, and run several Codys as a team.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

thinQit Cody

thinQit Cody in VS Code: the Mission Map beside the editor while Cody works, the chat with live steps and the review, and several Codys with their goals and plans

Your coding teammate from thinQit, right in VS Code. Ask a question or describe a change. Cody plans the steps and does the work at thinQit. Every edit lands in your editor, and you review each file.

Mission Map beside your editor

The Mission Map beside the editor while Ava runs the tests: her card at step 6 of 6, the green line to the part she works in, and the steps and changed files beside the map

Watch Cody work on a map of your project.

  • It opens beside your code, like a preview.
  • Your project shows as cards, sections and lines, as on the web.
  • Cody's card shows the step it is on and the progress.
  • A green line runs from Cody to the part it works in.
  • The files Cody reads and changes are marked on the map.
  • A pulse runs along the lines when you send a message, and while Cody works.
  • The steps and the changed files sit beside the map.
  • It follows the Cody you work with.

Open it with the map button in the Cody sidebar, or run thinQit Cody: Open Mission Map. Drag to move, scroll to zoom, click a card to open it. The map is made on your computer from your last commit. Nothing of it goes to thinQit. It follows your light, dark or high contrast theme and your Reduce Motion setting. A hidden or idle map draws nothing.

Chat: live steps, then your review

Left: the chat while Cody works, step 4 of 6 with its live line, clock and Stop. Right: the finished task with five accepted files and Commit and push

Type what you need and press Enter. Cody answers, or starts a task at thinQit.

  • Live steps. One live line names the step that runs, with a clock and Stop.
  • Each finished step folds to one line with its time.
  • Edits land in your editor as they happen, so undo works as always.
  • Review per file. Open the diff, then accept the file or revert it.
  • Revert keeps anything you typed after Cody's edit.
  • Commit and push. Once you accepted the files, one click commits exactly those files with your own git and pushes your branch.
  • Nothing else in your working tree goes along, and a push is never forced.
  • Plan, Ask first or Auto. Choose how much Cody does by itself.
    • Plan makes a plan you can trim, and nothing changes until you run it.
    • Ask first asks before every change on your computer.
    • Auto edits, tests, builds and commits by itself.
    • Auto still asks before risky steps, such as a push you did not ask for or a production deploy.
  • Questions first. A new request starts with a short round of clarifying questions. Click your answers, or choose Just do it.
  • Threads. Keep several conversations per project, each with its own tasks.
  • Stop at any time. Edits made so far stay, and you can revert them.

The modes and threads show as soon as your thinQit workspace offers them.

Several Codys, one team

Left: the Codys overview with Ava, Ben, Mila and Noor, each with a plan, a goal and a status. Right: Ava's steps, where she asked Ben how orders charges shipping

Run several Codys in one workspace, each with a job of its own.

  • Each Cody has its own name, goal and plan.
  • The strip above the chat names the Cody you work with.
  • Open it to see every Cody: name, goal, plan and status.
  • Pick a Cody to see its own chat, threads and tasks.
  • Rename a Cody or edit its goal right there.
  • A Cody's goal steers every task it does.
  • Add Cody picks a plan, a name and a goal, then opens the payment page in your browser.
  • A Cody waiting for its payment has a Pay button.
  • The Mission Map follows the Cody you pick.

Teamwork. The Codys of one workspace work as a team, never across workspaces.

  • Team status. Each Cody sees what the others work on: their goal, their task and its step.
  • Ask a teammate. A Cody can ask another Cody a question. The teammate answers from its own work and changes no file. The plan of the Cody that asks pays for the answer.
  • Team notes. The Codys share one page of team notes. You read and edit it in thinQit on the web.

With one Cody, the panel looks as it always did. Several Codys and teamwork show as soon as your thinQit workspace offers them.

More that Cody can do

  • Screenshots of changes. Ask Cody to show what it changed, such as a page of your app. The picture shows in the chat with Open and Save to workspace. When Cody cannot show the page, it says why.
  • Guided Playwright tests. Cody writes Playwright tests for your app and runs them guided. Each failure is sorted: a real bug, a timing problem, the environment, or a fault in the test itself.
  • Show Cody the spot. Right click a spot on a page in Cody's browser, or draw on a screenshot. Cody gets the element, where it sits in the code and a picture of it.
  • Your command line tools. Cody runs your signed in tools, such as gh, az, gcloud, aws, kubectl and docker. Reading is free. Outside Auto, every change shows the exact command and waits for your Allow.
  • Attach files. Pictures, PDFs and text files, up to 10 files of 25 MB each.
  • ArtifaQt pages. Cody publishes a page from a task, such as a test report, private to your workspace.
  • Test driven. You approve the test cases. Cody sees each test fail, then makes it pass.
  • Project memory. Cody keeps notes on what it changed and decided. You confirm which ones guide later tasks.
  • Connectors. Give Cody tools outside your repository, from MCP servers.
  • Merge conflicts. When a pull stops on conflicts, Cody resolves them, in five rounds at most.

Screenshots and guided tests run where your thinQit workspace offers them. The sections below tell more.

Plans and usage

The Credits view: 1,854 credits, Cody's use per day this month, the credit packs excl. VAT, and a Q-Max plan with this week's allowance, the 5-hour window and the automatic top up

One credit is EUR 0.10. All prices exclude VAT. 21% VAT is added when you pay. Cody runs on a Q-plan, on credits, or on both. With several Codys, each Cody has its own plan.

Credit packs. Buy one in thinQit, or with Add credits in the panel.

Pack Price excl. VAT
250 credits EUR 25
1,250 credits EUR 125
5,000 credits EUR 500

Q-plans. A monthly plan gives Cody a weekly allowance in thinQit tokens.

Plan Price a month excl. VAT Allowance a week Cody work for your money
Q-Explore EUR 9.99 620,000 thinQit tokens up to 1.5x
Q-Boost EUR 29.99 3,750,000 thinQit tokens up to 3x
Q-Max EUR 119.99 40,000,000 thinQit tokens up to 6x
Q-Extreme EUR 399 133,333,333 thinQit tokens up to 8x

"Up to 3x" means up to three times the work per credit.

  • The week resets every Monday at 00:00, Amsterdam time.
  • Each 5-hour window allows one sixth of the week.
  • While your allowance has room, a task uses it before any credit.
  • After the allowance, Cody continues on credits.

Automatic top up. When a task starts below 50 credits, your saved card pays. It buys 250 credits (EUR 25 excl. VAT) and Cody carries on. Automatic top up only starts if you agreed at checkout. There is no spending cap. Switch it off or on again in the Credits popover, when your workspace offers the switch.

What a task costs on credits. A task is charged for the work Cody did. A typical change uses about 75 credits. When a task starts, thinQit holds some credits. When it ends, you pay what it used. The rest comes back. A task that fails before Cody starts costs nothing. A task that fails after it started costs what it used. A task you stop costs what it used. So does a task that reaches its credit limit. Replies that do not start a task are not charged. The panel shows the credits of each task when it ends. While a task runs, nothing is charged yet.

Pictures. A picture is priced by its size and quality. The card shows the price before you choose Generate. The price list is under Images in Capabilities. On a Q-plan a picture counts toward your allowance. On credits it is charged with the task.

ArtifaQt pages. A page has no price of its own. The task that writes it counts like any task. Keeping its versions and sharing it cost nothing.

Capabilities. An optional capability adds its own price per use. The price shows next to its switch.

On a partner's workspace the prices can differ. A partner may bill your credits itself. The Credits view always shows what applies to you.

Sign in

  1. Open thinQit Cody in the activity bar and choose Sign in.
  2. Allow thinQit Cody on the thinQit page in your browser. You come back to the editor signed in. If the browser cannot open the editor, copy the code from the page and choose Paste code.
  3. The first time, Cody gets ready for your project. This happens once per repository. On a slow connection it takes a few minutes, and you can keep working.
  4. Type a message and press Enter.

For a private GitHub repository, thinQit Cody: Set Git Token is an optional faster way. A fine grained token with read only access to Contents lets Cody fetch it directly. It is stored encrypted at thinQit and never shown again.

Requirements

  • A folder that is a git repository, with the git command available.
  • At least one commit. Any host, or none.
  • A thinQit account with a Cody plan or credits.
  • VS Code 1.95 or later.
  • Remote SSH, WSL, Dev Containers and Codespaces work: the extension runs next to your files.

Privacy

  • The extension talks only to the thinQit address in thinqitCody.server. It sends no telemetry.
  • Your sign in token is kept in the editor's secret storage and can be revoked in thinQit under Settings, Integrations, VS Code, or with Sign Out.
  • Connector secrets you type in the panel go to thinQit when you save and are not kept by the extension.
  • Attachments and Cody's own files are stored by thinQit, private to your workspace, for 30 days, and are only served through your signed in editor; a file you delete is gone at once.
  • ArtifaQt pages are stored by thinQit and private to your workspace. Only a share link you switch on shows one outside it, and switching it off ends that link at once. Open in editor loads nothing from outside.
  • When Cody cannot reach your repository from its remote, your editor gives Cody the tracked files of the commit you are on, committed secrets included, and after that only what a new commit changed. Never an untracked or ignored file, never the objects of the history. The commit log goes along as names, dates, messages and file names, without e-mail addresses and without diffs.
  • Review state (the originals needed for Revert) stays on your computer in the extension's workspace storage and is removed when every file is accepted or reverted, or after 7 days.

Commands

Command What it does
thinQit Cody: Sign In Signs in through the browser
thinQit Cody: Enter Sign In Code Pastes the code from the thinQit page (fallback)
thinQit Cody: Sign Out Signs out and revokes the editor token
thinQit Cody: Open Panel Opens the panel and focuses the message box
thinQit Cody: Open Mission Map Opens the Mission Map beside the editor (also the map button in the panel's header)
thinQit Cody: New Chat Starts a new conversation; the next task starts a fresh session
thinQit Cody: Stop Stops the running task
thinQit Cody: Accept All Accepts every file of the latest task
thinQit Cody: Revert All Reverts every file of the latest task
thinQit Cody: Commit and Push Opens the commit form for the accepted files of a task
thinQit Cody: Add Cody Adds a Cody to your workspace: a plan, a name and a goal
thinQit Cody: Add Credits Opens the Credits view of the panel
thinQit Cody: Open Threads Opens the list of threads
thinQit Cody: Next Mode Moves to the next mode (Shift+Tab in the message box does the same)
thinQit Cody: Resolve Conflicts Opens the merge conflicts card for a merge or rebase that stopped
thinQit Cody: Switch to thinQit Opens the task you are looking at in thinQit, in your browser
thinQit Cody: Continue the Task in the Cloud Lets Cody carry on with the running task in the cloud
thinQit Cody: Show Cody This Points Cody at the code or files you right clicked
thinQit Cody: Toggle TDD Switches test driven mode on or off
thinQit Cody: Open ArtifaQts Opens the list of the project's ArtifaQt pages
thinQit Cody: Show Task Log Opens the log of tasks
thinQit Cody: Set Git Token Gives Cody read access to the repository
thinQit Cody: Open Memory Opens the Memory tab of the panel
thinQit Cody: Open Connectors Opens the Connectors tab of the panel
thinQit Cody: Open Connector Opens thinQit in your browser on the Connectors card of one connector of the library (a pick list from the palette)

Some commands show only while your thinQit workspace offers their feature.

In the message box: /ask asks about the repository without changing files, /do starts a change right away, /new starts a fresh session and /stop stops the running task. Type / to see these and the commands of your capabilities.

Settings

Setting Default Meaning
thinqitCody.server https://app.thinqit.io The thinQit address (partner domains work the same way)
thinqitCody.agent auto Agent for new messages in a project where you picked none in the panel: your account default (Cody), Pixy, Cody or Vexy
thinqitCody.hostChat true Send messages through the conversation host, which grills every new request with a clarifying round first; off starts a task for every message
thinqitCody.autoApply true Apply edits as they arrive; off makes every edit wait for a click
thinqitCody.sync.exclude [] Extra glob patterns of files that Cody never sees and never writes without a click
thinqitCody.context.terminal true Include the active terminal's last commands and output
thinqitCody.context.problems true Include errors and warnings from the Problems view
thinqitCody.context.relevantFiles true Send the paths of up to 8 files the local index ranks as relevant
thinqitCody.ship.enabled true Offer Commit and push under a task's accepted files; off hides the button

The status line

In the bar of the message box:

  • Mode: Plan, Ask first or Auto where your thinQit workspace offers them, else Ask (read only, a question) or Change; and Test driven (see TDD mode). Shift+Tab in the message box, or thinQit Cody: Next Mode, moves to the next mode.
  • Settings: the agent (Pixy, Cody or Vexy, see below) and the reasoning level (Quick, Balanced, Deep, and thinQit Ultra where the engines have it), each with Back to the default. Replies are always short. A level shows its typical credits and time only once thinQit has measured enough real tasks at it.
  • Agent: next to Settings, once you picked another agent than your account's default. Arrow keys on it move between Pixy, Cody and Vexy.

The line under the box is one quiet line: the branch (its full name on hover) and, once the newest task is charged, what it cost. The mode shows in the box only. The dots at the end of the line open Details:

  • the branch in full and the base commit,
  • Working memory: how full it is and what fills it (the conversation, files Cody read, the project memory, tool results), what your next message does, Summarise and continue and Start fresh,
  • Credits: this task, this session and your balance, with Add credits,
  • Approvals: what you allowed for this session, with Revoke.

Arrow keys on a focused chip change its value. Your choices are remembered per project and travel with every message.

Agents: Pixy, Cody, Vexy

Three agents can do the work. Pick one in the Settings popover of the status line; it is remembered per project and travels with every message.

Agent In short Good for
Pixy Quick and frugal Small, clear tasks: a rename, a typo, a lookup
Cody The everyday choice Most work. The default
Vexy The heavy thinker Hard problems and changes across many files. Slower, and it uses more credits

The agent and the reasoning level are two separate choices: the agent is who does the work, the level is how long it thinks. Once you picked another agent than your account's default, an agent chip stands next to Settings; arrow keys on it move between the three. For projects where you picked none, thinqitCody.agent sets the agent (auto follows your account). An agent shows its typical credits and time once thinQit has measured them. With a thinQit server that offers no agents yet, the panel shows none and sends none.

Images

When a task saves an image in your workspace, for example a screenshot, its file row shows a thumbnail and Open in place of Diff (an svg keeps Diff, because it is text). When Cody's message names the file, by its path or by its file name, the image shows under that paragraph, at most 4 per message. A click opens the file in the editor's own image preview.

Only image files of that task that are in your workspace are shown. The panel never loads an image from an internet address, and an svg is shown as a picture, never as markup. An image you revert, or that Cody deletes again, leaves the chat. An image over 10 MB shows a chip to open it instead of a preview.

Your browser and command line tools

The first time Cody wants to use something on your computer for a project, it asks: Allow for this project or Not now. After that:

  • Reading is free. Commands that only read (for example git status, gh repo view, az account show) run without asking, and Cody reads pages on your dev server in its own browser.
  • Every change asks. A card shows the command exactly as it will run, why Cody wants it, and the folder, with Allow once, Allow for this session and Do not allow. Destructive commands (a delete, a reset, terraform apply) ask every time. Any other local address than your dev server asks before Cody reads it, and running script in a page always asks with the full script shown. In Auto, a change with the project's own tools runs without a card when nothing risky is found; Plan runs no change at all.
  • Never. Shells, inline code, more rights, secret stores, environment dumps, credential files, secrets on the command line and options that make a command launch another program are refused.
  • Right click to ask. Right click anywhere on the page in Cody's browser and a small box opens at that spot: type what Cody should do there and press Send (Ctrl+Enter), or Cancel (Esc). Cody gets your words with the page's title and address, the element under the click (a short selector, its tag), a screenshot with the spot marked, and the element's HTML (up to 8 KB), as one chat message marked From the browser. Switch it off with thinqitCody.browser.pickPrompt; a right click then goes to the page.
  • The visual editor. Where your thinQit workspace offers it, "Right click anywhere to instruct Cody." stands under the toolbar (thinqitCody.browser.pickHint hides it), and Pick an element on the toolbar works with a click. The box names the element (Wider and Back move to its parent and back), Cody also gets where it sits in the code, and your message shows it as a chip such as Element: button "Pay now". When Cody's first reply offers to show where a change goes, Cody's browser opens your page and waits for your right click. After the task your dev server's page shows the change with the element outlined; on a deployed site you see it after the next deploy.
  • Cody needs you. When a page needs you (a sign in, a captcha, a sandbox payment), a card asks you to do it in Cody's browser beside the editor and press Continue.
  • Dev server. Cody can start your project's dev, start, serve or develop script after you allow it; the card shows what the script runs. It stops when the task ends.

Commands run without a shell, in a folder inside your project, with your own sign ins. Output is scrubbed of secrets before Cody sees it. Cody's browser has its own profile, never yours; its cookies and storage stay on your computer. Details at the end of the line under the message box shows what you allowed for this session, with Revoke. Files that make the editor run programs (.vscode/tasks.json, .vscode/launch.json, workspace files) are never written without your click.

Attachments

Add files to the next message with the plus in the message box, by dropping them on it (from your desktop or the explorer), or by pasting a picture. Allowed: pictures (png, jpg, gif, webp), PDF, and text files (json, xml, csv, yaml, md, txt, log, html), at most 25 MB each and 10 per message. Each file shows as a chip with its upload progress; Send waits until every file is through. A file that is refused says why under its chip: the wrong type (also a file whose content is not what its name says), too large, empty, one too many, or a file that seems to hold a password or a key.

After sending, the chips stay under your message. A click opens the file; the bin deletes it from thinQit. Files are kept 30 days and are private to your workspace; thinQit never makes a public link to them.

Cody's own files

When Cody makes something for you, such as a screenshot of your app or a test log, it shows in the chat: a picture as a card with a preview, other files as a chip, each with Open and Save to workspace. Nothing lands in your repository unless you save it. They come back after a reload and are kept 30 days.

ArtifaQt

An ArtifaQt is a page Cody publishes from a task: a test report, a UI check, an architecture document or another document. thinQit hosts it, private to your workspace: only signed in members can open it.

Ask Cody to make a page of what it did or found. A run in TDD mode publishes its report by itself.

The task ends with a card: the title, the kind, the version and a summary.

  • Open in editor shows the page in an editor tab. Its scripts run in a sandbox that loads nothing from outside. A link in the page opens only after your click and a second click on Open in browser at the bottom of the tab.
  • Open in browser opens the page on thinQit, signed in.
  • Versions. A later task that changes the page adds a version. Pick any version on the card. When nothing changed, the card says so.
  • Share. Switch it on for a link anyone can open without signing in, and Copy link. The link shows the version that was newest when you switched sharing on, and later ones; older versions stay private. Switch it off and the link stops working at once.
  • While Cody is still publishing the page, the card says so and updates by itself.

The ArtifaQts tab, or thinQit Cody: Open ArtifaQts, lists the project's pages, newest first, with the same buttons and Delete. ArtifaQt shows as soon as your thinQit workspace offers it.

TDD mode

In TDD mode you and Cody agree on the test cases before any code changes. Cody then writes each test, sees it fail, and makes it pass.

Pick Test driven in the Mode chip of the status line, type /tdd and, if you like, your goal, or run thinQit Cody: Toggle TDD. Without the status line, use the TDD button next to the message box. A form opens: the goal, then one line per case with what should happen and its kind (Unit, Integration or UI). Write the cases yourself, or press Draft cases and check what Cody drafts. A run holds at most 20 cases. Nothing runs until you press Approve and start.

While Cody works, a checklist in the task shows each case: Planned, Seen failing, Seen passing, Observed in the browser, Failed or Not verified. The test runs fold under it, each with its command, exit code and counts. At the end:

  • A case passes only when a test run or a check in the browser proved it, and its line says which.
  • A UI case checked in your browser shows its screenshot. A click opens it in the editor.
  • A case that was not checked before the task ended shows as Not verified, never as passed.
  • One summary line, such as "TDD: 7 of 8 cases passed, 1 not verified.", and the report as an ArtifaQt card under the checklist.

TDD mode shows as soon as your thinQit workspace offers it.

Ship: commit, push and deliver

Outside Auto, Cody never commits, pushes or deploys by itself: your own git and sign ins do, after your click. Three ways in, one form:

  • Commit and push under a task whose files you decided, or the command thinQit Cody: Commit and Push.
  • Cody proposes it when you ask it to commit, push, ship or deploy (in your own words or with /ship): the same form opens filled in with Cody's message and files, and you can change both.
  • Single git or delivery commands Cody runs through your command line tools, each approved like any other change.

The form shows the subject and an optional body, the files (the accepted ones checked; other changes unchecked; files you have not decided yet listed apart), the branch and where the push goes, and the commands exactly as they will run. Those commands run one after the other, each as one line you can open for its output. When the push is refused because the remote moved, the same click brings the newer work in first: your other changes are set aside, the newer work is pulled, your changes go back, and the push runs again. It never forces a push, never amends a commit and never skips your hooks.

When bringing the newer work in needs you (the same lines changed on both sides, history rewritten on the remote, or a merge or rebase still in progress), the form says so in one sentence and offers the commands to run, never a force push. Where your thinQit workspace offers it, Cody resolves merge conflicts itself (see Merge conflicts). A repository without a pull setting rebases, unless that would flatten a merge of yours. When the branch takes pull requests only, the commit goes to a new branch and the pull request opens (GitHub, Azure DevOps, GitLab and Bitbucket).

In Auto. Each change task that ends in Auto gets a commit of its own: exactly that task's files, never a file that may hold a password or key. One line in the chat names it, with Undo the commit. Cody pushes only when you ask, and a push to the default branch asks once per session. Cody sorts out a branch that takes pull requests only, a branch name already taken or newer work on the remote by itself, never with a forced push.

When the project has git hooks, Auto lists them once per session before its first commit or push: each hook and the commands it runs, also the ones that came with the repository, with Run them in Auto. Until you click it, Auto commits and pushes nothing, and Cody's own git commands that run hooks (a commit, merge, pull, rebase, switch or checkout) wait as well. The confirmed hooks show under Details, in Approvals, with Revoke; a hook that changes or comes new asks again.

Delivery. Cody learns how your project is delivered from a cody.deploy block in your instructions file, your workflow files or your deploy scripts. After a push the editor watches the pipeline (with gh for GitHub) for up to an hour and tells you in the chat when it passed or failed; on a failure Ask Cody to look at it starts a task with the failed jobs' last lines.

Switch the button off with thinqitCody.ship.enabled.

Merge conflicts

When a pull, or Ship bringing in newer work, stops on merge conflicts, a card above the message box names the files and takes the conflict to the end. It shows as soon as your thinQit workspace offers it. thinQit Cody: Resolve Conflicts opens it for a merge or rebase that is already stopped in your repository.

  • Ask first: one click. Let Cody resolve them, or I will do it myself. In Plan the card works as in Ask first.
  • Auto: by itself. The card says "Cody is resolving them." and has Stop. The git hooks line of Auto (see Ship) comes first.
  • The round. Cody makes the pull again as it stopped, with your uncommitted changes set aside, then runs a task that resolves the conflicts in those files. The chip under your line says the round, for example Round 1 of 5.
  • The check. After the task the editor reads the files itself. A file that still has conflict markers is named, with Let Cody try again, I will do it myself and Abort the pull. When all are resolved, the card shows the next commands exactly as they will run: the files added, the rebase continued or the merge committed, your changes back, and the push when you asked for one.
  • Continue. In Ask first one click: Continue and push, or Continue when you asked for no push. In Auto at once, after the project's own tests pass (at most 10 minutes). When the tests fail, or Cody finds none, it stops before the push and says so.
  • A push that needs you. A push the safety rules hold (it delivers, goes to the default branch or goes to another address) is never part of Continue: the pull is finished first, and the push waits on the card with Push or Close.
  • Five rounds at most. A rebase that stops again on its next commit is the next round. After five, Cody stops and you finish or abort the pull in your own tools.
  • Your work is safe. Changes that do not go back cleanly get a round of their own and also stay in the stash, named, until you choose Drop it. Abort the pull first keeps your other changes in a stash entry of their own, "Cody: before abort".

Cody never forces a push, never changes your git configuration and never drops a stash entry you did not drop.

Connectors

Connectors give Cody tools outside your repository, from servers that speak MCP (the Model Context Protocol). They belong to your thinQit workspace, so they work in every project and every editor you sign in with, unless you limit a connector to one project. Open the Connectors tab (or thinQit Cody: Open Connectors) to add, edit, switch off, test or delete them; thinQit's Settings has the same list.

Above them, the Library section lists the connectors of your thinQit workspace (GitHub, Gmail, Azure, AWS, Teams, Slack) with whether each is connected and as which account. A click on a row, or thinQit Cody: Open Connector, opens thinQit in your browser on the Connectors card of that connector, where you connect it and set what Cody may do with it; back in the editor the tab shows the new status. The library shows as soon as your thinQit workspace offers it.

Kind What it is
Remote server An MCP server on the internet. Cody connects from thinQit with the headers you give, for example Authorization: Bearer <token>.
Local server A server package (npm or Python, with a pinned version) that runs next to Cody at thinQit for each task. Only packages on the thinQit allow list run.
thinQit thinQit's own tools, with your rights in this workspace.
Your own config files An .mcp.json file and a config.toml fragment for the two engines, used as they are.

Ask before changes. Every connector has this switch, on by default. A tool that creates, sends or deletes something then waits in the task: a card shows the connector, the tool and its arguments (secrets removed), with Allow and Skip. Skip tells Cody you did not allow the call. Reading never asks. The task waits up to 10 minutes for your answer. Under "Which tools ask" you can name tools that should always ask or never ask.

Test connects once and lists the server's tools, with what each one does in a task: reads, asks first, or runs without asking. For a local server the test checks the allow list; its tools are listed when a task starts it.

Secrets are write only. Header values, variable values and config files are sent to thinQit once when you save, stored encrypted, and never shown again: the list shows header and variable names and the last 4 characters of a value. Leave a value empty when you edit to keep it.

Honest limits.

  • Connectors you added to an AI assistant's own website or desktop app belong to that sign in, so Cody cannot use them. Cody keeps its own connectors: add them here.
  • Servers in your own config files act without asking: Cody cannot ask you before they change something. You are responsible for what they start.
  • A .mcp.json file at the root of the repository is used as well. Its servers are not in the list and act without asking.

Capabilities

Capabilities are what thinQit adds to Cody, released with thinQit itself: no update of the extension is needed for a new one, unless it says it needs a newer version. The extension asks thinQit for the list when the project is ready and again every 10 minutes.

Part What you see
Commands Extra slash commands in the message box, for example /review or /tests.
Cards A Cards tab with results, for example the last test run or the latest screenshots.
Connector presets Ready made connectors in the Connectors tab's Add connector menu.
Tools in Cody's workspace Tools Cody can use during a task, for example a test runner or screenshots.

Standard and optional. Open the settings (the gear in the panel) to see the Capabilities section. Standard capabilities are always on. Optional ones have a switch and show their price per use, in credits; some cost nothing and are still counted. Your administrator can switch a capability on or off for the whole workspace; it then has no switch here. When a capability needs something you do not have yet (a connector, an engine, a newer extension), the section says what, and offers Add connector when a preset fits.

Commands with arguments. Pick a command from the / menu and a small form opens above the message box: a text, a file (type the path or choose it with Choose) or a choice from a list. What you type below the form is added to the command. You can also type the whole line, for example /tests lib/naming.ts only the edge cases: values fill the arguments in order, name=value sets one by name, and the rest is extra text. When a required argument is missing, the form opens. A command always starts a task in its own mode (a question or a change); the line you typed shows in the chat.

Cards. The Cards tab appears when a capability that is on has cards. Each card has its own Refresh; while the tab is open, cards refresh on their own interval, and after each task. An item can open a file of the repository or an https page.

Connector presets. A preset fills in the server and which tools ask first; you fill in its token or variable fields. Values are write only, like every connector secret: sent to thinQit once and never shown again. A token field may add Bearer in front of what you paste.

Tools that ask first. A capability tool that asks first waits in the task like a connector call: a card shows the capability, the tool and its arguments (secrets removed), with Allow and Skip. The task waits up to 10 minutes.

Memory notes Cody writes. Only notes you wrote and notes you confirmed guide later tasks. Each note Cody wrote has Confirm; a confirmed note shows Confirmed and has Remove confirmation.

What is sent, and what is never sent

Before every task the extension brings Cody up to date with your local changes, so Cody works on exactly what you see. What leaves your computer:

  • the commit your work is based on (the last commit you pushed, or where your branch left the remote default branch),
  • every change since that commit: unpushed commits, staged and unstaged changes, new files that git does not ignore, and unsaved editor buffers,
  • nothing when nothing changed since the task before.

Files in .gitignore never leave your computer.

Left out files. Cody gets only the text it needs:

  • Pictures, videos, archives and fonts stay on your computer.
  • So do build output, such as dist, build, out and .next.
  • So do dependency folders, such as node_modules, vendor and .venv.
  • So does a file over 2 MB.
  • So does a new file over 1 MB.
  • Cody is told which files were left out.
  • A picture you name goes along, up to 10 MB.
  • Add a .codyignore file, one pattern per line, to leave out more.

A question or a greeting never waits. If your changes are too big, Cody works from your last push. One notice then offers three choices:

  • Leave them out
  • Commit and push for me
  • Show the files

Commit and push never forces a push. On a protected branch it makes a cody/wip branch.

With each message the extension sends context: the path of the active file, the visible lines, your selection (at most 16 KB, never from a secrets file or a file your exclude setting covers), the paths of open files (at most 20), up to 50 problems, the last three terminal commands with their output (at most 8 KB), the branch name, and the paths of up to 8 relevant files with a score. File contents are not sent as context.

Relevant files. At the first message the extension builds a small word index of the files git tracks (no file over 256 KB, no binaries, lockfiles, minified bundles, node_modules, dist, build or .next, and never a secrets file or a file your exclude setting covers). It stays on your computer, in the editor's storage for the extension, and only the paths it ranks are sent. Switch it off with thinqitCody.context.relevantFiles.

Never sent. Files that usually hold secrets are withheld and never written by Cody without your click: .env files (except .env.example, .env.sample and .env.template), keys and certificates (*.pem, *.key, *.p12, *.pfx, *.jks, *.keystore, id_rsa*, id_ed25519*), credential files (.npmrc, .pypirc, .netrc, .git-credentials, .aws/, .ssh/, .docker/config.json, credentials.json, service-account*.json, secrets.json and similar data files), Terraform state and variables, and anything matching thinqitCody.sync.exclude. A changed file that contains something that looks like a key or token (cloud keys, Git tokens, model API keys, Slack and Stripe keys, private keys, long JWTs, thinQit tokens, or a password assignment) is withheld as well, and the panel tells you which file. In your selection, terminal output and problem messages such values are replaced with [redacted].

Limit of the filter. Secrets that are already committed to your repository are part of what Cody works on. Remove them from the history if they must not be there.

Engines

Cody can run a task on two coding engines and picks one for every task by itself; there is nothing to choose. When the engine fails, stalls or hits a limit, the other one takes over once and the task card says so.

Support

Questions and problems: thinqit.io/support. Please include the output of thinQit Cody: Show Task Log; it holds no file contents and no tokens.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft