Grok Build Plugin

The Keito plugin for Grok Build connects Grok to Keito’s hosted MCP server. With it, Grok can:

start and stop timers
log finished work and LLM usage
record expenses
summarise project time

All of this happens without leaving your terminal.

Keito publishes the plugin from the public osodevops/keito-grok-plugin repository. xAI does not make or endorse it.

What It Does

The plugin:

Adds Keito’s hosted MCP server at https://mcp.keito.ai to Grok Build.
Adds a keito-time-tracking skill. It tells Grok to check your Keito workspace, look up projects before writing, and confirm any write where it had to guess a value.
Connects with OAuth in your browser. You do not copy a Keito API key into Grok Build.
Runs no local code. It contains no hooks, scripts, or binaries.

The plugin only acts when Grok calls a Keito tool during a session. It does not track time in the background.

Requirements

Before you connect:

You need a Keito account on a paid plan with access to the clients, projects, and tasks you want Grok to use.
You need Grok Build installed with plugin support. Check with grok --version.
Write actions, such as starting timers, creating time entries, or logging expenses, need the matching Keito permissions on your user.

Install The Plugin

Install the plugin from GitHub:

grok plugin install osodevops/keito-grok-plugin@v1.0.0 --trust

To pin the exact release content, use the release’s full commit SHA instead of v1.0.0. Grok Build checks that the fetched commit matches.

Then load the plugin. Open /plugins and press r in the Plugins tab, or start a new Grok Build session. To confirm what was installed, run:

grok plugin details keito

It should list one MCP server, keito, and one skill, keito-time-tracking.

Connect Your Keito Account

In Grok Build, run /mcps.
Select keito and press i.
Sign in to Keito in the browser window that opens and approve access.
Return to Grok Build.

Grok Build registers itself with Keito’s sign-in service automatically, so you don’t need to configure OAuth client settings. Grok Build stores the resulting tokens on your machine.

Verify The Connection

Ask Grok:

Use Keito to show my current user, company, and running timer.

Grok should call Keito tools and return your Keito user and company. “No timer is running” is also a successful response.

You can also check the server from your terminal:

grok mcp doctor keito

What You Can Use It For

Find Clients, Projects, And Tasks

Do this first when you log work against a project for the first time.

Use Keito to list my active clients, then show projects for Valueleaf Ltd and the tasks under each project.

Tool	Purpose
`keito_whoami`	Show the authenticated user and current company.
`keito_list_clients`	Find client records available to your account.
`keito_list_projects`	Find active projects and project codes.
`keito_list_tasks`	Find tasks scoped to a project.

Start And Stop A Timer

Start a Keito timer for project Website Platform, task Development, with the notes "Grok Build: API pagination".

When you finish:

Stop my running Keito timer.

Tool	Purpose
`keito_get_running_timer`	Check whether a timer is already running.
`keito_start_timer`	Start a running time entry.
`keito_stop_timer`	Stop the current timer or a specified timer.

If a timer is already running, Grok tells you which one and asks before replacing it.

Log Finished Work

Create a Keito time entry for 1.5 hours today on project Website Platform, task Documentation. Notes: "Wrote API usage guide."

Grok uses keito_create_time_entry, and keito_update_time_entry when you ask it to correct an entry.

Log LLM Usage

Log LLM usage in Keito for project Website Platform: provider xai, model grok-build-0.1, 250000 input tokens, 180000 cached input tokens, 40000 output tokens.

keito_log_llm_usage works out the amount when the model is in Keito’s price table. For any other model, include the amount in your request. Use keito_create_expense for expenses that aren’t LLM usage.

Review Time

Summarise my Keito time for 2026-09-01 to 2026-09-14 by project and task.

Tool	Purpose
`keito_list_time_entries`	Pull detailed time entries with filters.
`keito_get_time_entry`	Fetch one time entry.
`keito_report_team_time`	Pull a team time report for a date range.
`keito_list_expenses`	Pull expenses, including LLM usage.

Approvals And Confirmations

Grok Build’s permission mode decides when Grok asks before calling a tool:

Default mode: Grok asks for approval before each Keito tool call.
Auto or always-approve mode: Grok can call Keito tools without asking.

The keito-time-tracking skill adds its own check. If you didn’t give Grok the project and every value, Grok shows the write it plans to make and waits for you to confirm. For billing-sensitive work, ask for a dry run:

Show me the Keito time entries you would create, with project, task, date, hours, and notes. Don't write anything until I say "create them".

Security And Permissions

The plugin uses OAuth with PKCE. Grok Build never needs your Keito password or an API key.
Grok can only reach Keito data and actions that your authenticated Keito user is allowed to use.
Grok Build connects to two Keito hosts: https://mcp.keito.ai for MCP tool calls, and https://auth.keito.ai for sign-in and tokens.
Deleting time entries is not available through the plugin. Delete entries in the Keito web app.
Invoices, estimates, and client or project administration are not available through the plugin.
Google Calendar data, and time entries or reports built from Google Calendar events, are not available through the plugin.
Keito returns data to Grok only when Grok calls a Keito tool in your session. Keito does not choose the xAI model or control xAI’s retention and training settings. Your xAI account and agreement with xAI govern those.
Keito does not use Customer Data to train or improve generalized or shared AI or machine-learning models.
For each tool call, Keito’s server keeps an audit record with these fields: user and company IDs, tool name, a hash of the arguments, result status, latency, client information, and source IP. It does not log tokens, cookies, API keys, or raw tool arguments.
Keito keeps a connection record for Grok Build. It holds the OAuth client ID, the latest session ID, the client name and version, when it was first and last used, and when it was disconnected. You can review and disconnect it under Connected AI apps.
The plugin’s source is public. Every release is a fixed commit you can inspect before installing.
If you open https://mcp.keito.ai in a browser and get a 401, that is normal. MCP requests need OAuth.

Disconnect The Grok Build Plugin

To revoke Grok Build’s access to Keito:

In Keito, go to Settings → Integrations → Connected AI apps.
Click Disconnect next to Grok Build.

Grok’s next Keito request is rejected. To use Keito again, you must sign in from /mcps.

To remove the plugin from Grok Build:

grok plugin uninstall keito

Uninstalling the plugin does not revoke access in Keito, so disconnect in Keito as well. Time entries and expenses created through Grok stay in Keito.

Troubleshooting

Symptom	What to check
Keito tools do not appear	Run `grok plugin list` to check the plugin is installed and enabled. Then press `r` in the Plugins tab or start a new session. Plugins installed without `--trust` do not load MCP servers.
Keito shows as needing authentication	Run `/mcps`, select keito, and press `i`.
Browser shows `401` at `https://mcp.keito.ai`	That is expected. The endpoint requires OAuth.
Grok is writing to the wrong workspace	Ask Grok to run `keito_whoami`. Disconnect in Keito and sign in again with the correct account.
Grok says no client or project matched	Ask Grok to list clients or projects first, then use the exact stored name.
A timer won’t start	Another timer is running. Stop it first, or explicitly ask Grok to replace it.
LLM usage is rejected for a missing amount	The model is not in Keito’s price table. Include the amount in your request.
Sign-in fails or loops	Run `grok mcp doctor keito`, then try `/mcps` → `i` again. If it still fails, contact Keito support with the time of the attempt.