MCP Tools for Personal Agents: Choose, Connect, and Test

Choosing MCP tools starts with a task you want your personal agent to complete. Converting a meeting time, scaling dinner ingredients, and cleaning a copied list each need clear inputs and a result you can check. Everyday MCP provides these calculations through a remote connection that a compatible agent application can call.

This guide is for people using Claude, Codex, or personal assistants, as well as developers building those experiences. You can follow the selection and testing process without writing code; the short configuration example and developer appendix explain the details needed when your application exposes them.

Personal agents cover a broad range of everyday work. Meta describes Muse as an agent that works across apps, Instinct describes an assistant you can text or call, and Wajo describes Fo as an agent that calls, emails, and coordinates everyday tasks. Those examples identify the audience for this guide; an Everyday MCP connection to these products has not been verified.

How do I choose MCP tools for a personal AI agent?

Choose MCP tools by matching a specific task to documented inputs, outputs, permissions, and failure behavior. Check that your agent application accepts the server's connection type, then run a small example with a known answer. For timers, separately verify stored state, notification delivery, and the application's ability to resume work.

Everyday MCP is an anonymous remote tool service for everyday calculations, time and date operations, unit conversions, and text processing. Its published catalogue contains 14 tools, and its endpoint requires no Everyday account or API key. It suits agents that need explicit calculation results and can connect to a remote MCP server; timer notifications depend on additional client support. The current tool catalogue describes the available operations.

Choose MCP tools around the result you need

Write the desired output before choosing an integration: “a meeting time with a date and zone,” “ingredients for six servings,” or “a list with exact duplicate lines removed.” This makes it easier to distinguish a calculation from a task that also requires access to an account, a device, or another person.

An agent application manages your conversation and available tools. A connected server performs the operations it exposes; the MCP specification describes the application as the host, its connector as the client, and the service providing capabilities as the server.

Use these questions to assess a candidate:

A useful tool can have a narrow scope. If it accepts ingredient quantities but has no pantry connection, provide the quantities explicitly and treat the output as a calculation over that input.

The machine-readable catalogue exposes Everyday MCP's tool descriptions and schemas. A schema specifies the fields an operation accepts, their types, and their limits; an application can use it to prepare a valid request.

Compare remote MCP setup with the tools you already have

Choose the option that fits the task and where you want to perform it. A connection adds another service to your workflow, so there should be a concrete reason to use it.

Keep a suitable native calculator for a one-off calculation you can finish directly. A remote tool becomes useful when the result feeds a larger agent workflow, such as converting quantities before preparing a shopping list.

Account access is a separate requirement. A meeting calculation can compare availability that you supply; reading your calendar or sending an invitation requires an appropriate connector and permission. Everyday MCP does not synchronize account calendars or send invitations.

The connection type also matters. Official MCP transport documentation describes local stdio connections and remote Streamable HTTP connections; Everyday's public endpoint uses Streamable HTTP. A host offering only local command-based setup needs a separately documented path for remote services.

Connect Everyday MCP in eight steps

Complete the steps in the application where you intend to use the tools. Successful discovery and an executed result provide stronger evidence than a saved server entry alone.

1. Confirm your application's remote connection support

Look for current instructions for adding a remote MCP server, custom connector, or HTTP tool server. Confirm that the setting accepts an endpoint URL and that your account or workspace permits custom connections.

If your personal agent provides no documented way to add a remote service, ask its provider about that capability. A product exposing its own MCP server does not, by itself, establish that it can connect to another server.

2. Read the tool and permission information

Start with a synthetic conversion so the first request contains no personal information. Review the tool descriptions your application displays and keep its permission controls available while testing.

Remote requests send their supplied arguments to Everyday MCP for processing. Anonymous access removes the Everyday account requirement. Your agent application may also retain conversation and tool history under its own policies.

3. Add the endpoint using your host's format

Use https://everyday.alfie.family/mcp as the server URL. The installation record provides the endpoint and service access details; configuration syntax still follows your application.

For example, the current Claude Code MCP documentation requires an explicit HTTP type in a JSON entry. This is the corresponding configuration shape:

{
  "mcpServers": {
    "everyday": {
      "type": "http",
      "url": "https://everyday.alfie.family/mcp"
    }
  }
}

This example follows Claude Code's documented format; an end-to-end Claude Code installation was not tested for this guide. For another host, use its documented fields or URL form, and preserve any existing server entries.

4. Confirm tool discovery

Open the application's tool list or ask the agent to inspect its available Everyday tools. Check for recognizable names such as unit_convert, time, and everyday_calculate.

The published catalogue contained 14 tools when this guide was prepared. Your application's interface may group or defer them, so verify that the particular operation you need can actually be selected and called.

5. Run a conversion with a known answer

Ask: “Use Everyday MCP's unit conversion tool to convert 1 kilometre to metres, and show the returned result.” The unit_convert arguments are:

{
  "dimension": "length",
  "value": 1,
  "from": "km",
  "to": "m"
}

These fields go directly in the tool's arguments object. This tool has no request wrapper. The recorded live call returned:

{
  "dimension": "length",
  "value": 1,
  "from": "km",
  "to": "m",
  "result": 1000
}

Check the tool activity or execution details as well as the conversational answer. An agent can produce “1000 metres” from its own knowledge, so the answer alone does not establish that the connection worked.

6. Check a relevant boundary

Choose a case that matters to your intended task. For recipe shopping, enter the same ingredient once in grams and once in cups and inspect whether the quantities remain separate.

In the recorded shopping example, 1 US_cup of flour and 100 g of flour produced separate entries. That confirms the documented boundary for that example: the tool does not infer ingredient density to combine mass and volume.

7. Complete one small everyday workflow

Try a real task with inputs you are comfortable sending to the service. Confirm each intermediate result before the agent formats the final answer, particularly if it performs several operations.

For a shopping list, review the serving count, scaled quantities, and merged names. If the result will later be sent to another app, perform that transfer only through a separately available and authorized operation.

8. Record what you verified

Keep a short note with the application version, endpoint, tested operation, input, and observed result. Record timer delivery separately if you intend to use reminders.

Repeat the affected check when the application, configuration, or server behavior changes. A recorded passing conversion establishes a useful baseline without implying that every tool or background feature has been tested.

Use MCP tools for three everyday tasks

The following scenarios show how to supply enough information for a useful result. The recipe and shopping numbers come from recorded live calls; the scheduling and text examples are suggested workflows to verify in your own application.

Find a meeting time across time zones

A person arranging a call with family abroad needs a date and each person's time zone. Specify names such as America/Los_Angeles and Europe/London, which identify the time-zone rules the tool should use.

For one proposed time, use time to convert the dated instant. For several people's available hours, use the date tool's meeting_intersection action with the meeting date, each participant's zone and available window, the desired duration, and the interval between proposed start times.

A useful request is: “Find a 30-minute overlap on this date, using the availability I provide, and show every candidate in each person's local time.” Include those availability windows explicitly; the calculation has no access to the participants' calendars.

Check the result before making plans:

• Confirm that the local date is correct for every participant, including any next-day result.
• Confirm that the full meeting duration fits inside each supplied window.
• Resolve any missing or ambiguous local time instead of asking the agent to assume an offset.

Everyday's time tool rejects ambiguous and nonexistent daylight-saving wall times. If you receive that error, provide a clearly identified instant or choose an unambiguous local time, then perform the conversion again.

Scale a recipe and combine the shopping quantities

A home cook increasing a recipe from four servings to six can provide each ingredient's quantity and explicit unit. The everyday_calculate tool's recipe_scale action applies the serving ratio to the quantities and returns both exact fractions and readable mixed fractions.

The recorded example produced these results:

The same test then combined those quantities with another list. Adding 3/4 US_cup of rice, 1/4 kg of beans, and 1 US_tbsp of olive oil produced totals of 3 US_cup, 700 g, and 4 US_tbsp.

Review ingredient names before combining them. The merge operation normalizes spacing, case, and Unicode representation, but leaves synonyms and plural variants separate: the recorded egg and eggs test returned two entries.

Use the original cooking instructions as a separate reference. Scaling preserves instruction text; it does not calculate a new cooking time, temperature, pan size, or technique. The tool also does not place a grocery order or make a payment.

Clean a copied list or prepare text for another app

A volunteer organizing an event might copy a list from several messages and want exact duplicate lines removed before sharing it. Supply the text and the desired transformation, then compare the result with the original.

Everyday's text_transform tool includes line deduplication, whitespace operations, casing, supplied HTML-to-text conversion, and removal of tracking parameters from a supplied URL. Select the operation that matches the change you intend.

For example, start with a synthetic list containing the same line twice and a third line with different capitalization. Ask for case-sensitive deduplication and check which lines remain; then decide whether ignoring case is appropriate for the real list.

These operations work on supplied text. They do not fetch the contents of a web address or verify that extracted contact information belongs to the intended person. Keep an original copy so a formatting change remains easy to review.

What should I test before relying on an MCP timer?

Test timer creation, later lookup, cancellation, expiry, and notification delivery in the application you will use. Everyday MCP stores timer state and returns a secret access token for later operations. Whether you receive a visible reminder or the agent resumes work depends on the client's event handling and background behavior.

Creating a timer returns its identifier and access token. Keep both in an appropriate private store supported by your application: the token is required for later access, and there is no account-based recovery if it is lost.

Everyday's event integration follows experimental work. The official Triggers & Events working group repository labels its contents exploratory and outside the official MCP specifications and recommendations. Support for ordinary tool calls therefore needs a separate check from support for these events.

Use a harmless test label and a short duration for the first timer. Treat each row below as an observation to make in your own setup; this guide's recorded live examples did not create timers or test notification delivery.

A fired state establishes that the server processed expiry. Record whether a notification appeared and whether any requested follow-up action happened as separate results. If your client only supports polling, a reminder requires something to perform that later check.

The documented retention window removes terminal timers 24 hours after they fire or are cancelled. The service also cannot guarantee punctual delivery during an outage. For a time-sensitive task, use a reminder system whose behavior you have verified under the conditions you expect.

Never place a timer token in a URL, query string, public document, or diagnostic log. Timer capabilities belong in the relevant tool arguments, and any shared troubleshooting record should omit them.

Diagnose an incomplete MCP setup

When a test fails, identify the earliest step that did not complete. Keep the original error message and the operation name; remove secrets and personal input before sharing diagnostic details.

Do not solve an input error by removing information the calculation needs. If a time-zone conversion rejects an ambiguous time, resolve the date and offset; if a shopping quantity has an unspecified cup definition, establish which unit the recipe uses.

A working conversion also provides a useful diagnostic comparison. If unit_convert succeeds while another operation fails, capture that distinction so you can investigate the failing request without assuming the whole connection is unavailable.

A short appendix for agent developers

Use a compatible MCP client library to handle the protocol and transport, and discover the current tool definitions. Everyday documents MCP 2026-07-28 with legacy support for earlier clients; the exact behavior should be checked against the client version you ship.

The official tools specification defines discovery through tools/list, invocation through tools/call, and tool schemas. Let those schemas determine argument construction: unit_convert accepts top-level fields, while operations such as everyday_calculate use a request object.

Keep these application responsibilities explicit:

• Validate required inputs before calling, and surface the returned error when a request fails.
• Preserve units, time zones, and exact quantity strings when passing results between tools.
• Distinguish calculations from state changes such as creating or cancelling timers.
• Protect timer capabilities in storage, logs, traces, and exported conversations.
• Test event handling independently from request-and-response tool calls.

Use the 1 km to 1000 m example as a connection check, then add a representative boundary for each workflow you expose. For an assistant that prepares shopping lists, verify both compatible-unit merging and the separation of mass and volume.

Avoid blindly repeating state-changing requests after an uncertain response. Establish whether the original operation succeeded before creating another timer or feedback submission, and provide enough context for the user to understand an unresolved result.

Start with one verified workflow

A practical setup begins with one operation whose inputs and answer you understand. Confirm that the connection executes it, inspect a relevant boundary, and then use it in a small daily task.

Keep the scope of that verification clear. A successful conversion supports using the calculation path; timer delivery, calendar access, and actions in other accounts each require their own capabilities and checks.

For Everyday MCP, the first connection can use the documented endpoint and a synthetic unit conversion. Once that works, choose the time, kitchen, or text workflow you actually need and verify its output before adding another dependency. Follow the Everyday MCP agent guide for the current connection details and tool instructions.