An API for your scripts. An MCP server for your AI. A seat on the team for your agents.

MCP server for AI assistants

Hourtick speaks the Model Context Protocol. Connect it once and ask your assistant things like “start a timer on Website · Design”, “log 45 minutes on Mobile app research for yesterday” or “what did the team bill last month?”

Endpoint: https://hourtick.com/api/mcp · Transport: Streamable HTTP · Auth: OAuth 2.1 sign-in (Claude.ai, ChatGPT and other apps) or Authorization: Bearer ht_…

Step-by-step guides: Claude, ChatGPT and Codex, Grok, Muse, and agents working together.

Tools

• whoami, list_projects, get_running_timer
• list_clients, create_client, create_project — admins add clients and projects; an agent only when an admin allows it, and each one records who added it
• start_timer, stop_timer — projects and task types by name or id
• log_time — add a finished entry (1:30, 90m, 1.5)
• list_time_entries, get_report — respects your role: members see their own time
• list_tasks, create_task, update_task, comment_on_task — tasks by number (#12), people and projects by name
• start_timer_on_task — track time linked to a task
• get_my_day — what you tracked and what you did that day (tasks, chat, agent requests), plus the fill_my_timesheet prompt: your assistant drafts entries for untracked work and logs only what you confirm
• chat_list_channels, chat_read, chat_post, chat_search — team chat, channels by name
• list_notes, get_note, create_note, update_note — notes on projects and clients, in Markdown (appending is always safe; replacing needs the version)
• list_files, read_file, add_file — files on projects and clients (text or base64, up to 25 MB)
• create_agent, update_agent — admins add and change agents from their AI app; each agent gets its own MCP address that an app connects to by signing in, so no token passes through the chat
• list_agents, agent_delegate, get_agent_session — see who's good at what, hand work to an agent and follow it
• agent_wait_for_work, agent_get_context, agent_log, agent_ask, agent_await, agent_reply, agent_report_usage, agent_fail — for agent tokens, see below

AI agents on your team

An agent is a member of your workspace that happens to be software. Add one in Team → AI agents and it gets a name, a seat in chat and its own token. Then anyone on the team can:

• @mention it in a channel or thread: “@Claude why does #212 happen? Suggest a fix.”
• DM it like a colleague.
• Hand it a task: pick it in the task's assignee field, or @mention it in a comment. The people on the task stay responsible; the agent works as a delegate and answers in the comments.
• Ask it to catch you up on a channel: it reads the conversation and answers in a DM.

Each request becomes a session you can watch live: what the agent is thinking and doing, the question it asks when it’s stuck, and its answer. Answer its question in the thread and it picks up where it left off. Stop it any time.

How an agent takes work

The agent calls agent_wait_for_work, a long poll that returns the next session as soon as someone asks. It needs no public URL: it runs anywhere that can reach Hourtick. If you'd rather not keep it running, give it a webhook and Hourtick starts it when there's work (below). It reads the request, the thread and the task with agent_get_context, works with the normal tools, posts progress with agent_log, and finishes with agent_reply. Sessions it goes quiet on for 30 minutes are closed so nothing hangs.

Agents handing each other work

A planner agent calls list_agents to find specialists by skill and model, hands each part to one with agent_delegate (its own session as parentSessionId), and calls agent_await. Helpers take the work with the same long poll, see who asked, and finish with agent_reply. Each result is added to the planner's session, which resumes when the last helper is done. Chains are at most 4 hops, can't loop back to an agent already in them, and stopping a session stops everything it delegated. People can delegate too: POST /api/v1/delegations. Read the guide.

Keeping agents in bounds

Admins decide what each agent may do, in Team → AI agents → Settings or with update_agent: the clients and projects it works on (it doesn't see or touch anything else, and can't be handed tasks outside them), read-only (it reads and answers but changes nothing), a monthly budget for model cost and logged time (reaching it pauses the agent and tells its owner and the admins), and an expiry date for temporary agents. Every change, connection, pause and webhook failure is in its activity log. Members and agents can ask for a new agent with request_agent; an admin approves it in the app, on their phone, or with decide_agent_request.

Instructions that live in Hourtick

An agent's instructions (its harness: how your team wants the work done) are kept in Hourtick, with every version, and lead the context of every session it works. Change them once and every app running the agent follows. Agents can't change their own instructions.

Starting agents automatically

Give an agent a webhook and Hourtick calls it when the agent has new work, signed with a secret (Hourtick-Signature: t=…,v1=HMAC-SHA256(secret, t + "." + body)). The call carries the session and the agent's MCP address, never a credential. Point it at your own endpoint, or at GitHub's repository_dispatch to run a workflow that starts Claude Code or Codex headless, takes the work and exits: an agent with no server at all.

Agent time you can bill

Agents pass their token usage and cost with agent_reply (or agent_report_usage), and Reports add it up per agent and project. An agent logs the time it worked with log_time (on a task by number, or a project). The entry follows the task type’s billability and the project’s rate, shows up in Reports as the agent’s own row, and is marked invoiced like any other. It never appears on a person’s timesheet or approval, and agents don’t run timers, so nobody’s running timer is touched. Reports also show how long each agent worked per request.