Timely connector for AI agents

Tools your time tracking agent reaches for on Timely, scoped per user.

CALL ANY TOOL

53 tools for time tracking in Timely: log time entries and run timers, manage projects, clients, tags, and teams, run filtered reports, and plan tasks against capacity.

timely_create_client

Create client

Create a client in a Timely account. Returns the created client with its id and name. Use timely_update_client to change an existing client.

Parameters

Name

Type

Required

Description

account_id

integer

Required

Timely account (workspace) ID that owns the data. Get it from timely_list_accounts. Example: 1234567.

active

boolean

Optional

Whether the client is active. Set false to archive it.

color

string

Optional

Hex color for the client without the leading #. Example: FF5733.

name

string

Optional

Client name. Example: Acme Corp.

timely_create_linked_work_item

Create linked work item

timely_create_tag

Create tag

timely_create_team

Create team

timely_delete_linked_work_item

Delete linked work item

timely_delete_tag

Delete tag

timely_delete_team

Delete team

timely_filter_reports

Filter reports

timely_get_client

Get client

timely_get_compliance

Get compliance

timely_get_insights

Get insights

timely_get_project

Get project

timely_get_tag

Get tag

timely_get_task

Get task

timely_get_team

Get team

timely_get_user

Get user

timely_list_accounts

List accounts

timely_list_current_user_permissions

List current user permissions

timely_list_linked_work_items

List linked work items

timely_list_roles

List roles

timely_list_tags

List tags

timely_list_teams

List teams

timely_list_user_capacities

List user capacities

timely_search_teams

Search teams

timely_start_timer

Start timer

timely_stop_timer

Stop timer

timely_update_client

Update client

timely_update_linked_work_item

Update linked work item

timely_update_tag

Update tag

timely_update_team

Update team

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);

// Timely tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["timely"], toolNames: [
    "timely_list_projects",
    "timely_create_time_entry",
    "timely_get_report_totals"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Log 2 hours on the Acme Redesign project for today" }] });

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: ["timely"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Log 2 hours on the Acme Redesign project for today" }],
  tools,
});

// Execute the tool call with the user's vaulted Timely 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: ["timely"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Log 2 hours on the Acme Redesign project for today" }],
  tools,
});

// Tool call runs with the user's vaulted Timely 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: ["timely"] }, pageSize: 100,
});

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

await agent.run("Log 2 hours on the Acme Redesign project for today");

Try these prompts

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

Time

Copy the prompt

Copied

Log 2 hours on the Acme Redesign project for today with the note design review.

Copy the prompt

Copied

Start the timer on my design review entry.

Copy the prompt

Copied

List my time entries from last week.

Reports

Copy the prompt

Copied

Show hours by client for October.

Copy the prompt

Copied

Who on the team is behind on logging time this week?

Copy the prompt

Copied

What was our billable utilisation last month?

Planning

Copy the prompt

Copied

Create a task for Maria to spend 6 hours on the Q4 audit next Tuesday.

Copy the prompt

Copied

Summarize planned tasks by project for next week.

Copy the prompt

Copied

Show weekly capacity for everyone on the Design team.

SEE HOW AUTH WORKS

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

Authorize

Your user connects

Timely

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

Timely

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

Timely

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

Timely

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 time tracking and project management 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 Timely token looks fine in a demo. In production every time entry the agent logs 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.

Timely 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 Timely as the user or through a shared service account?

As the user. Each user signs in to Timely once, and Scalekit stores and refreshes their tokens. Time entries and planned tasks the agent creates are attributed to that user in your audit trail, not a shared service account.

Where is the Timely 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 Timely?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example the report and list tools without timely_delete_time_entry or timely_delete_project, which permanently delete logged time and projects. Scalekit also enforces scope checks before every API call.

What happens when a user revokes Timely 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 check who is behind on logging time?

Yes. timely_get_compliance returns per-user and per-team time-logging compliance for a date window, and timely_get_insights returns billable utilisation and where the time went.