Teamwork connector for AI agents

Tools your project management agent reaches for on Teamwork, scoped per user.

CALL ANY TOOL

250 tools for project management in Teamwork: create and update projects, task lists, tasks, and milestones, log time and run timers, post messages and comments, and manage risks, expenses, invoices, and portfolio boards.

teamwork_activity_delete

Delete activity

Delete one entry from the activity feed. Returns an empty success response when the entry was deleted. Use only to remove a single feed entry. Find ids with teamwork_activity_list or teamwork_project_activity_list.

Parameters

Name

Type

Required

Description

activity_id

integer

Required

Id of the activity entry to delete. Example: 9501.

teamwork_activity_list

List activity

teamwork_calendar_event_create

Create calendar event

teamwork_calendar_event_get

Get calendar event

teamwork_calendar_event_update

Update calendar event

teamwork_invoice_add_time

Invoice add time

teamwork_invoice_complete

Complete invoice

teamwork_invoice_delete

Delete invoice

teamwork_link_category_create

Create link category

teamwork_link_category_update

Update link category

teamwork_links_list

List links

teamwork_me_get

Get me

teamwork_message_archive

Archive message

teamwork_my_status_set

Set my status

teamwork_notebook_category_delete

Delete notebook category

teamwork_portfolio_board_create

Create portfolio board

teamwork_portfolio_board_update

Update portfolio board

teamwork_portfolio_column_cards_list

List portfolio column cards

teamwork_project_get

Get project

teamwork_project_people_remove

Remove project people

teamwork_project_star

Project star

teamwork_project_time_entries_list

List project time entries

teamwork_search

teamwork_tag_create

Create tag

teamwork_tag_delete

Delete tag

teamwork_tag_update

Update tag

teamwork_task_dependencies_list

List task dependencies

teamwork_task_get

Get task

teamwork_task_workflow_stage_move

Move task workflow stage

teamwork_timer_start

Start timer

For more tools, view docs.

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Teamwork tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["teamwork"], toolNames: [
    "teamwork_project_tasks_list",
    "teamwork_task_create",
    "teamwork_task_time_entry_create"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "List the tasks due this week on the Website Redesign project" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["teamwork"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "List the tasks due this week on the Website Redesign project" }],
  tools,
});

// Execute the tool call with the user's vaulted Teamwork OAuth token
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["teamwork"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "List the tasks due this week on the Website Redesign project" }],
  tools,
});

// Tool call runs with the user's vaulted Teamwork OAuth token
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["teamwork"] }, pageSize: 100,
});

const agent = new Agent({
  name: "project_management_agent",
  model: "gemini-2.5-pro",
  instruction: "Teamwork tools scoped to this user",
  tools,
});

await agent.run("List the tasks due this week on the Website Redesign project");

Try these prompts

Copy any prompt into your agent. Each maps directly to a Teamwork tool. Click to copy, paste into your agent, done.

Projects

Copy the prompt

Copied

Create a project called Q3 Website Redesign for client Acme.

Copy the prompt

Copied

Show the summary counters for the Mobile App project.

Copy the prompt

Copied

List projects with a low health score.

Tasks

Copy the prompt

Copied

Add these 5 tasks to the Launch Prep task list.

Copy the prompt

Copied

Mark the Homepage Copy task complete.

Copy the prompt

Copied

List my tasks due this week across all projects.

Time and billing

Copy the prompt

Copied

Start a timer on the API Integration task.

Copy the prompt

Copied

Log 3 hours on the Design Review task for yesterday.

Copy the prompt

Copied

Create an invoice for Acme and attach this month's time entries.

SEE HOW AUTH WORKS

Each user signs in to Teamwork once, and Scalekit stores and refreshes their tokens. Credentials stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

Teamwork

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

Teamwork

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

Teamwork

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

Teamwork

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other project management and collaboration connectors.

Engineering Teams

Engineering standup agent

Pulls commits from GitHub and GitLab, tracks issue movement in Jira, and posts a per-engineer standup brief to Slack. Each engineer's activity is read on their own delegated OAuth.

Engineering Teams

Slack triage

Polls Slack for new messages, classifies bugs and support requests with a LangGraph router, files GitHub issues or Zendesk tickets, and confirms in the thread.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared Teamwork token looks fine in a demo. In production every task update and time entry looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Teamwork today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Teamwork as the user or through a shared service account?

As the user. Each user signs in to Teamwork once, and Scalekit stores and refreshes their tokens. Audit logs attribute every project, task, and time entry change to that user, not a shared service account.

Where is the Teamwork OAuth token stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in Teamwork?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example task and time tools without teamwork_project_delete, which deletes a project and everything inside it. Scalekit also enforces scope checks before every API call.

What happens when a user revokes Teamwork access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Can the agent undo a delete in Teamwork?

Yes, while the item is still in the trashcan. teamwork_trashcan_projects_list and teamwork_trashcan_project_items_list find deleted items, and teamwork_trashcan_restore brings back a deleted project, task, task list, milestone, message, notebook, link, file, time entry, comment, or expense.