Here is what that looks like, piece by piece.

Tasks that stay organised

My Tasks is everything assigned to you; Search all tasks is every task in your organization. Type a keyword or an ID, filter by status, priority, owner, project or date, and save the result as a view you can pin. Your search and filters are still there when you come back from another page, and the address keeps them, so you can send a colleague the exact same list.

• Table or board. Edit a task right in its row, or switch to a board with a column per status.
• Subtasks and blockers. Break work down, and link a task to the tasks it waits on so you can see what is holding it up.
• Newest first. A Created column puts what was just added at the top.

Projects

A project is where a body of work lives: its people, sprints, goals, milestones, resources and tasks, each in its own tab. Big projects split into sub-projects. Give a project a logo so it is easy to spot, and make it public (every member of the organization sees it) or private (only the people you add).

• Members and roles. Each person has a project role: owner, lead, manager, member or viewer.
• Everything inside. Tasks, milestones and goals are tabs of their project, not separate apps.

Planning in one place

Planning is your whole organization's work on one page: every project's sprints, everyone's capacity and every task. Sprints belong to projects, and Focus projects narrows the page to the ones you care about (yours, your pinned ones, or a hand-picked list) and remembers your choice.

• Goals that fill up. A goal's progress is the share of its tasks that are done, so it moves as the work does.
• Milestones on a timeline. Dated checkpoints with a Today line; drag one to change its date.
• Capacity. See who is away, day by day, before you commit to a sprint.

Work together

Talk about a task where the task is. A comment can carry up to 5 files of up to 100 MB each, and when a reply would be one word, react with an emoji instead. Each task has subscribers who get an email when it changes; whoever creates it and whoever it is assigned to are subscribed for you.

• Faces everywhere. Pick one of 36 illustrated avatars or upload a photo; it shows on tasks, comments and people pickers.
• Email you choose. Switch each kind of email on or off in your profile. Account and service email always arrives.

Your AI assistant, connected

TasKadence works inside Claude today: add it from the Claude directory. Ask about your work and Claude answers with interactive views for tasks, sprints, goals and projects, right in the chat. Any assistant that speaks MCP can connect too, including Cursor, VS Code, GitHub Copilot and Claude Code. ChatGPT and Microsoft 365 Copilot are coming soon.

• One connection, all your organizations. Choose All my organizations when you connect, and lists show which organization each item comes from.
• Every change on the record. What an assistant does is in the audit log under your name, and every task it creates carries a Bot mark.
• Review before it lands. Your organization, or a project owner, can hold agent tasks until a person accepts or rejects them.

The details are in TasKadence now works inside Claude and Use TasKadence from your AI assistant.

One account for your organizations

Many people run more than one organization: a company, a client workspace, a side project. Your account sits above the organizations you own, with one owner, one People directory and one bill, all in Settings > Account.

• 10 GB of free storage, shared by all the account's organizations. TasKadence is free for your whole team; you pay only for storage beyond that.
• Organizations that move. Move an organization to another account, or hand the account to a new owner.

More in One account, many organizations.

Secure by design

You sign in with a one-time code sent to your email, with no password to leak, and you can add two-step sign-in with an authenticator app; an organization's owners can require it. Each organization's data is kept apart in the API and by Postgres row-level security.

• Private files. Attachments are stored privately and open through links that expire after a few minutes.
• Audit log. Owners and admins see who did what and when, for people, tokens and apps alike.
• Encrypted in transit, backed up. Every connection uses HTTPS, and restoring from a backup is a procedure we rehearse.

How to report a vulnerability, and the rest of what we do, is on the Security page.

For developers

Everything your team does in the app, you can do in code. Tokens are scoped, belong to one organization, and can be revoked at any time.

• REST API, Python SDK and CLI. Tasks, projects, goals, milestones, sprints and webhooks over JSON, with a typed client and a command line for scripts.
• Webhooks and OAuth apps. Signed webhooks with retries, a delivery log and replay; register your own OAuth app for others to connect.
• MCP server. Remote or local, over OAuth or a token, read-only if you like.

Start at docs.taskadence.com.

Built to scale

Before launch we load-tested TasKadence on a full-size copy of production, with every customer working at once, and it stayed fast. The API scales out as you grow, and your data lives in managed Postgres.

Get started

TasKadence is free for your whole team. Sign up, create your first project, and add a goal and a few tasks; it takes a couple of minutes.

• Learn the basics in the Guide.
• Plan with your assistant: Plan a sprint in 5 minutes with your AI assistant.
• See how the views are built: How we built interactive views with MCP Apps.

Tell us what you think from Settings > Feedback.

The MCP Apps model

A view is an MCP resource. A tool names it in its metadata (_meta.ui.resourceUri, a ui://taskadence/<view>?v=<build> address), and the resource is one HTML document served with the MIME type text/html;profile=mcp-app. When a host that supports MCP Apps calls the tool, it reads that resource and loads it into a sandboxed iframe. The ?v= part is a hash of the view sources, so a host that caches by address picks up a new release.

Everything after that is JSON-RPC over postMessage, on a small set of ui/* methods:

• ui/initialize: the view says who it is and which protocol version it speaks; the host answers with its own name (hostInfo), the theme and its capabilities.
• ui/notifications/tool-input and ui/notifications/tool-result: the arguments of the call, then its result.
• ui/notifications/tool-cancelled: the person stopped the request.
• tools/call: the view calls a TasKadence tool, through the host, on the same connection and with the same permissions. Changing a status is an update_task call.
• ui/notifications/size-changed, ui/open-link and ui/message for the frame's height, links out, and a follow-up question.

Every result keeps its plain text as well. A host without MCP Apps, or a terminal client, gets the same answer it always did.

Data inline, no network

The standard lets a view ask the host for network access through a content security policy in the resource's metadata. Ours asks for nothing: connectDomains and resourceDomains are both empty, so the view runs under the host's default policy, which has no network at all.

That is a choice, not a limitation. All data a view shows arrives inside the tool result (structuredContent, with a little view metadata in _meta), and every change goes back as a tool call through the host. So:

• No token in the view. The HTML is the same file for every person. It never authenticates, so it has nothing to leak.
• One permission model. A view can do exactly what the connection's scopes allow, because it only ever calls the same tools the model calls.
• Nothing to break in a strict sandbox. Each view is built with Vite, TypeScript and Preact into one self-contained HTML file, JavaScript and CSS inline. A test scans the built files for fetch, eval, new Function, external loads and token prefixes.

One sandbox lesson came free: in a frame that allows scripts but not forms, a <form> submission is dropped before its submit event fires. Our first owner, due date and reply forms silently did nothing. They are buttons now, and a test fails on any <form>.

The late-subscriber race

Our first version could get stuck on its grey loading skeleton. We first blamed the host for not re-delivering a result to a remounted frame and added a fallback: after 4 seconds without a result, a read-only tool was called again with its original input. It didn't fix the problem. In a fresh chat, one question made the model call list_my_tasks twice; the second card rendered and the first stayed on the skeleton.

The cause was in our code. The hook that connected a view to the bridge read the bridge's state during the first render, but subscribed in an effect, which Preact runs after paint. A result that landed in between was never heard, and it had already switched off the stall timer, so the fallback never fired either.

The fix is a rule for the whole bridge: every message can arrive early, late, twice or never.

• The message listener is attached when the page loads, before the handshake, so nothing the host sends early is missed.
• The last tool-input, tool-result and tool-cancelled are kept, and anything that subscribes later gets them replayed at once.
• No view shows a skeleton for more than 8 seconds. Every request has a timeout: 8 seconds for the handshake and reads, 60 seconds for writes. After that the view offers Reload, never an endless skeleton.
• Fake hosts that answer early, never answer, send odd results or remount run against all eleven views.

Respecting cancel

When the person stops the assistant mid-answer, the host sends tool-cancelled. Our early views ignored it, so a cancelled request looked like a slow one and could even be fetched again.

Cancellation is now its own phase. Before a result, it switches off the stall timer, an in-flight re-fetch no longer counts, and nothing is retried on its own. A result that still arrives afterwards wins; a cancel after a result leaves the result on screen. The words depend on the tool, because the honest answer differs: a read says "Nothing was changed", and a write says "It may have gone through - check TasKadence before trying again", since we can't know whether the server finished before the stop.

About 20 KB a view

The first views used the official MCP Apps client library. About 60 KB of every view, gzipped, was that library with the MCP client and the schema validation it pulled in, for a view that needs a dozen messages. Preact and the view itself were around 10 KB.

So we wrote the view's side of the protocol by hand: JSON-RPC over postMessage, the replay above, ping and resource teardown answered, a timeout on every request, and height reports whenever the page resizes, the DOM changes or a floating menu opens. It imports the library's types only, which vanish at build time, and a test drives it with the SDK's real host-side AppBridge, so protocol drift fails a test, not a session.

The build measures every view the way it ships: it gzips the built HTML at level 9, writes the raw and gzipped bytes into the manifest next to the files, and fails above 150 KB raw or 40 KB gzipped. The eleven views went from about 75 KB each to between 20 and 27 KB gzipped, the richer ones (charts, burndowns, dependency graphs) at the top of that range.

One card per question

A model often makes a lookup to answer a different question: it finds the project before listing its sprint. Each of those calls used to draw a full card. Now every tool with a view takes display: "compact", and the view draws one line of about 40 px instead (its icon, its title, the server's one-line summary and a Show button that expands the card in place). The view knows it is compact from the tool input, before the result comes, so the host never reserves a card's height for it. An error, or a question the person has to answer, is always the full card.

Neutral by default

A view has to say things like "stopped this request" or "Couldn't connect to ...", and it should never name a host it may not be running in. So there is one place a view names the app it runs in: the hostInfo.name from the ui/initialize answer, cleaned to one short line and used as given. With no usable name (an older host, a test, a handshake that has not finished) the copy says "the assistant". The same rule covers every label and empty state.

How we test the views

• Unit tests (Vitest) render each view against a fake bridge: phases, the replay, cancel, compact lines, the host's name or the neutral word, and every view's empty and error states.
• Protocol tests drive the hand-written bridge with the SDK's own AppBridge and PostMessageTransport.
• A mock host loads the built files, the bytes the server serves, in an iframe with only allow-scripts, answers tool calls from fixtures (or never, to catch stalls), and a headless Chromium screenshots each view light and dark. That harness is what caught the form bug.
• CI rebuilds the views and fails when the committed files differ from the sources.

What we'd tell someone starting out

• Design the state machine for late, early, duplicate and missing messages first, and replay state to anyone who subscribes late.
• Carry the data in the result. A view with no network and no token has very little that can go wrong.
• Test in a sandbox as strict as the spec's example, against the built files, not the dev server.
• Measure the bundle in the build. A budget that fails the build is the only one that holds.

The account, above your organizations

An organization is still the workspace that holds projects with their sprints, tasks, goals and milestones, along with its members and their roles. The account sits above the organizations you own, and it is where the things that belong to you, not to one workspace, now live: who owns it, its people, its storage and its bill.

You find it in Settings > Account, in four tabs:

• Overview, for everyone in the account: its name, your role, and the shared storage pool with each organization's part. Owners and admins also see the account number.
• People, for the owner and account admins: one directory for the whole account. Add a person once, then choose which organizations they can reach with Organization access.
• Billing, for the owner only. Everyone else sees who manages it.
• Transfers, for the owner only: organizations being sent to or from your account.

One pool of free storage

The free allowance belongs to the account, not to each organization: 10 GB of file storage free per account, shared by all its organizations. Settings > Storage shows the pool first, with each organization's part of it. Storage beyond the pool is billed per GB-month on the daily average, on one card with one invoice for the whole account, on the 1st of each month. Only the account owner adds the card or changes billing, in Settings > Account > Billing.

Moving an organization to another account

Organizations can now change hands. The account owner starts it from the organization's Settings > General > Transfer organization, with the other account's number and its owner's email. The request waits in that owner's Transfers tab for 7 days, to accept or decline.

The account itself can change hands too: from Overview, the owner can make an account admin the new owner, and stays on as an admin.

Nothing waits unseen

When something needs the owner (a transfer to accept, one of yours still waiting, or a card that was declined), a small badge with the count appears on Settings in the sidebar and on the Account tabs, so it is not missed.

Your Claude connection keeps working

The account needed no new scopes and no reconnect. A connection set up for All my organizations keeps covering every organization you belong to, and Claude's Storage view now shows the account's pool. More on the connector is in TasKadence now works inside Claude.

In short

• One account above your organizations, with one owner and one People directory.
• 10 GB of free storage per account, shared by all its organizations, with one bill beyond that.
• Organizations can move between accounts, and the account can get a new owner.
• Find all of it in Settings > Account.

This guide walks through one sprint from start to finish, in six steps. The prompts are examples; phrase them however you like. They work in any assistant connected to TasKadence over MCP.

Before you start

You need:

• TasKadence connected in your assistant. The steps for each one are in our docs: Connect. If you use Claude, TasKadence is also in the Claude Connectors Directory.
• a project in TasKadence, because sprints belong to a project
• a connection that is allowed to work with projects, sprints and tasks (you choose this on the consent screen when you connect)

If you belong to several organizations and connected with "All my organizations", the assistant will ask which organization when a request could apply to more than one. Naming the project usually settles it.

Views or text. Some assistants show TasKadence's answers as interactive views (Claude does today); the others answer in text, with the same data. This guide names the views where they help, and every step works either way.

Step 1: Find your project and see what is waiting

Start by getting your bearings.

List my projects and how far along each one is.

Show the open tasks in the Website project, highest priority first.

The assistant uses list_projects and then list_project_tasks. Where views show, the projects appear as the Project view and the tasks as a task list you can act on.

If your candidate work is spread across projects, search instead:

Search for tasks that are not started and due before the end of the month.

Step 2: Check the last sprint

Before planning the next sprint, look at how the last one went.

Show the Website project's sprints.

What is still open in the last sprint?

list_sprints returns each sprint's dates, status and task counts, and list_sprint_tasks lists the tasks in one sprint, filtered by status if you ask. The Sprint view shows day N of M, done against total and, where the task history allows it, a burndown chart.

If the last sprint is over, you can close it:

Mark the last Website sprint as completed.

Step 3: Create the sprint

Create a two-week sprint in the Website project called "Sprint 14", starting next Monday. The goal is "Ship the new import flow".

create_sprint takes the project, a name, a start date, and either an end date or a length in weeks, plus an optional goal and description. If you want to adjust it later:

Move Sprint 14's end date to the Friday after it ends and rename it "Sprint 14: import".

Step 4: Fill it

There are two ways to add work.

Move existing tasks in. Give the assistant the ids, or describe them:

Add T812063, T812070 and T812071 to Sprint 14.

Carry everything still open from the last sprint over to Sprint 14.

The assistant files each task with set_task_sprint. A task can only go into a sprint of its own project.

Create new tasks straight into the sprint. Ask for a draft first:

Draft these tasks for the Website project in Sprint 14, but don't create them yet:

• Import: CSV column mapping
• Import: progress and error report
• Import: docs page Make the docs page a subtask of the error report.

The assistant calls create_tasks with a preview, which writes nothing. In assistants that show views, the Create tasks view shows the draft as editable rows: change titles, owners and due dates, untick what you don't want, and press Create. In the others, the draft comes back as a list; say what to change, then "create them". One call can create up to 50 tasks with shared defaults such as the project and sprint, and a task can be a subtask of an earlier one.

Step 5: Set owners, priorities and order

Before assigning, check who has room:

Who's overloaded right now, and who has room for more?

get_workload answers in one call: open work per person, with in progress, blocked, overdue and due this week, and each project's sprints as lanes (the Planning board view, where views show). To see who is on the project:

Who is on the Website project?

Bulk changes are one request:

In Sprint 14, give the three import tasks to priya, set them to high priority, and set every due date to the sprint's end date.

update_tasks changes up to 100 tasks at once, with shared values and per-task overrides. Then record what has to happen first:

T812071 depends on T812063.

add_dependency records it, and tasks show "Blocked by" and "Blocks" from then on.

Step 6: Review the plan

Show Sprint 14.

Which tasks in Sprint 14 are blocked, and by what?

The sprint answer gives you the overview. Ask for any task to see its blockers, subtasks and recent activity (the Task detail view, where views show). If something doesn't fit, take it out:

Take T812070 out of Sprint 14.

During the sprint

The same conversation works for check-ins:

How is Sprint 14 going? Are we on pace?

Move T812063 to in progress.

Where views show, you can also change a task's status from the status menu in the view, and every view links to the same page in the TasKadence web app: Planning, or the project's Tasks, Milestones and Goals tabs.

A few tips

• Name the project and the sprint. It saves the assistant a lookup and avoids a "which one?" question.
• Ask for a draft first when creating several tasks. Nothing is written until you confirm.
• Use ids when you have them. TasKadence ids (like T812063) work in any organization the connection covers.
• Everything is recorded. Changes made through your assistant show up in each task's history like any other change, and the task's subscribers get the usual email.

Five minutes is a goal, not a promise: it depends on how much is in your backlog. But the clicking is gone, and you keep the decisions.

People can now see their tasks, sprints, goals and projects as live views inside Claude and act on them without leaving the chat.

Indrasol today released a major update to TasKadence for Claude, the connector that brings its work management platform into Claude conversations. Ask Claude what is on your plate, how a sprint is tracking or whether a goal is at risk, and the answer now arrives as an interactive view in TasKadence's own look, not a block of text. From the view, people can change a status, add a comment, move a card or create tasks, and Claude asks for approval before any change.

TasKadence has been listed in the Claude Connectors Directory since October 2026. This update adds the views, a single connection across organizations and a quieter product overall.

What's new

• Interactive views inside Claude. Eleven views cover the core of the work, each following Claude's light or dark theme and showing only real data from the person's workspace.

• One connection for every organization. A single connection can now cover all the organizations a person belongs to. Lists show which organization each item comes from, changes to an item go to its own organization, and Claude asks when a request could apply to more than one.
• Built for trust. Claude uses the same permissions as the person who connected it. Every change made through Claude is recorded in the TasKadence audit log under that person's name. Organizations that require two-step sign-in stay protected until the person signs in again.
• A quieter product. One short notification per event in the app, and a refreshed set of account emails.

Quote

"Most work updates already start as a conversation: a question in a standup, a note after a meeting, a quick 'are we on track?'. We wanted TasKadence to meet teams there," said Rithin Gullapalli, Product Architect at Indrasol. "Now you ask Claude, see the real state of your work in a view you can act on, and know that every change is recorded exactly as if you had made it in TasKadence yourself."

Availability

The update is available today to every TasKadence user at no cost. People who already connected TasKadence get the views automatically, with no reconnection needed. New users can find TasKadence in Claude under Customize, then Connectors, or at claude.ai/directory/taskadence. Setup steps are at docs.taskadence.com/mcp. TasKadence is free for the whole team, with no per-seat pricing.

Learn more at taskadence.com. Logos, screenshots and product descriptions are at taskadence.com/brand.

About Indrasol

Indrasol delivers end-to-end solutions for AI and LLM development, cloud-native engineering, data platforms and security, helping organizations innovate faster and more safely. Indrasol builds TasKadence. Learn more at indrasol.com.

About TasKadence

TasKadence by Indrasol is a work management platform for teams. Projects hold sprints, goals, milestones and tasks; Planning shows every project's sprints and everyone's capacity, and progress rolls up as the work gets done. People and AI agents work side by side: TasKadence works with Claude through its connector, and with any AI agent through its public API, SDK and webhooks, and every action an agent takes is recorded in the audit log.

Media contact

TasKadence team, Indrasol taskadence@indrasol.com

Claude is a product of Anthropic. TasKadence is not affiliated with or endorsed by Anthropic.

###

The connector

TasKadence is listed in the Claude Connectors Directory: find it in Claude under Customize → Connectors, or at claude.ai/directory/taskadence. It runs an MCP server, the open protocol Claude uses to talk to other tools, so adding it as a custom connector works too:

Name: TasKadence
URL:  https://api.taskadence.com/mcp

The URL is the same for everyone, and there is nothing to copy or paste after it. The setup steps for Claude, Claude Desktop and other clients are in our docs: Connect.

Once connected, Claude reads and changes the real records: "what's on my plate this week?", "create these five tasks in the onboarding project" or "what is blocking T812063?".

Some things stay in the app on purpose: inviting people, changing roles, tokens, webhooks and organization settings have no tool.

One connection for every organization

Many people belong to more than one organization: their company, a client workspace, a side project. A connection used to belong to one organization, and Claude was refused the moment you asked about another one.

Now, if you belong to two or more organizations, the consent screen offers All my organizations as the default, with each single organization listed below it if you want to keep things narrower. With "all" selected:

• Lists cover everything. "Show my open tasks" searches every organization the connection covers, and each row says which organization it came from.
• Ids resolve themselves. Ask about a task, project or sprint by its id and TasKadence works out which organization it lives in.
• Claude asks when it can't tell. If "create a task" could go to more than one organization, Claude asks you which. Nothing is written until that is settled.
• New organizations are included. Join another organization later and the same connection reaches it, with no reconnect. Leave one and it drops out.

You can always ask Claude "who am I connected as?" and it will list the organizations the connection covers, with your home organization marked.

Interactive views

Text answers are fine for a quick question, but a list of twenty tasks reads better as a list you can act on. Claude supports MCP Apps, an extension of the protocol that lets a tool's answer come with a small interactive view. We built eleven of them, plus a shared set of states (loading, stopped, error, empty) that every view uses.

Your tasks

My tasks groups your work by status, with counts for open, due this week, overdue and blocked. You can change a status from a menu, and clicking a title opens the task.

Task detail shows the description, what blocks it, what it blocks, its subtasks (which you can tick off) and recent activity, with a box to reply to comments.

Create tasks is a draft first. When you ask Claude to create several tasks, it can show them as editable rows before anything is saved. You change titles, owners or dates, untick what you don't want, and press Create.

Which organization? appears when a request needs you to pick an organization, with one option per organization.

Planning

Project shows progress, weekly throughput, sub-projects and tasks. Sprint shows day N of M, done against total and a burndown chart. Goals shows a progress ring per goal, and Milestones puts milestones on a timeline.

Planning board, storage and your connection

Planning board answers "who is overloaded?" in one call: open work per person across your projects, with in progress, blocked, overdue and due this week, and each project's sprints as lanes. It links to Planning in the web app. Storage shows how much of your account's free storage is used and what takes the most room. Connection shows who Claude is acting as, which organizations it covers and what it is allowed to do, in plain words.

What we were careful about

• Real data only. Every number in a view comes from TasKadence. When the data for a section doesn't exist (for example a burndown without task history), the section is hidden rather than filled with something made up.
• The text stays. Every answer still carries its plain text, so Claude can reason about it and clients that don't show views get the same answer as before. Claude Code's terminal, for example, shows the text.
• No network from the views. A view never fetches anything on its own and holds no token. It gets its data from the tool answer, and any change you make goes back through Claude to the same tools, with the same permissions as the connection.

We wrote up how we built the views, including a few bugs we had to chase, in How we built interactive views with MCP Apps.

Getting started

If you already have TasKadence connected in Claude, the views come to your connection without reconnecting. If you connected for a single organization and want all of them, connect again and pick All my organizations on the consent screen. If you haven't connected yet, add the connector, sign in, and try "show my open tasks".

TasKadence is an independent product built by Indrasol. Claude is a product of Anthropic, and this post does not imply any endorsement by Anthropic.

What the connection is

TasKadence runs an MCP server. MCP, the Model Context Protocol, is an open standard that lets an AI assistant use tools from other products. Connecting TasKadence gives your assistant a set of tools for your tasks, projects, sprints, milestones, goals and saved views, and it works with the same records your team sees in the app.

You connect once. Your assistant sends you to TasKadence to sign in, and a consent screen shows what it is asking to do. If you belong to more than one organization, you choose All my organizations or a single one. You approve, and the assistant keeps its own token from then on.

What you can do from your assistant

• Find work. "What's on my plate this week?", "show the open tasks in the Website project", "what is blocking T812063?"
• Plan. Create a sprint, fill it with existing tasks, or draft several new tasks and create them only when the draft looks right.
• Update. Change a status, an owner or a due date, reply to a comment, react to one, or move a task into a sprint.
• Check in. "How is Sprint 14 going?", "who is overloaded right now?", "which goals are at risk?"

Every answer comes back as text your assistant can reason about. Assistants that support MCP Apps also show it as an interactive view, such as a task list with status menus or a sprint with its burndown, which you can act on directly. Where an assistant doesn't show views, you get the same answer as text.

Who it works with today

Any assistant that speaks MCP can connect. The ones we have tested and documented, with setup steps for each, are:

• Claude (on the web, Claude Desktop and Claude Code)
• Cursor
• VS Code with GitHub Copilot
• Codex
• Gemini CLI
• Windsurf
• Zed

Most of them connect with one URL, https://api.taskadence.com/mcp. Some can also run our local package instead. The steps for each are in our docs: Connect. If you use Claude, TasKadence is also in the Claude Connectors Directory; TasKadence now works inside Claude walks through it.

Your permissions, nothing more

An assistant connected to TasKadence can only do what you can do, and only within the scopes you approved on the consent screen. Some things stay in the app on purpose: inviting people, changing roles, tokens, webhooks and organization settings have no tool. Admin tools, such as deleting a task, stay off unless you ask for them when you connect.

Every change an assistant makes is recorded in the TasKadence audit log under your name, and shows up in each task's history like any other change. If your organization requires two-step sign-in, a connection stays blocked until you sign in again.

Getting started

1. Pick your assistant in our Connect guide and follow its steps.
2. Sign in to TasKadence and approve the consent screen.
3. Ask "show my open tasks".

If something doesn't work, ask your assistant "who am I connected as?". It lists the organizations the connection covers and what it is allowed to do. You can also contact us from the Help menu in TasKadence.