Introducing MCP Tasks on FXMacroData

By FXMacroData Team
Published on May 25, 2026

FXMacroData MCP now supports asynchronous task execution, which means an AI client no longer has to block on every multi-step macro workflow. Instead, it can start a task, keep the session responsive, and poll for completion when the result is ready.

The first task-capable workflow is a compact macro briefing builder. Give it a currency, and it assembles a structured briefing from the indicator catalogue, latest policy rate, recent GDP, and upcoming events from the release calendar. For traders and agent builders, that turns a small chain of data lookups into one managed unit of work.

What’s New

The new Tasks capability extends FXMacroData MCP beyond immediate tool calls. A client can now:

• start a task-capable tool without waiting for the full workflow to finish in the initial response;
• check task status separately through MCP task polling;
• retrieve the final result when the task completes;
• keep a chat or agent session responsive while background work continues.

That matters most when a request needs several related macro lookups stitched together into one answer. A simple data fetch still works synchronously. A richer research step can now be handled as a managed task.

Why It Matters for Traders

Traders rarely think in isolated endpoint calls. They think in decision packets: what is the current rate, what is the latest growth signal, what events are next, and how does that change the setup in pairs such as EUR/USD or USD/JPY?

That is exactly where Tasks help. Instead of making the model orchestrate several small calls and hold the whole interaction open, the workflow becomes one tracked unit. The client can start a briefing, keep working, then pull the completed answer when it is ready.

• Fewer brittle agent chains: one task replaces a sequence of loosely coordinated sub-calls.
• Better UX in MCP hosts: long-running work no longer has to feel like a stalled session.
• Cleaner research handoff: the finished result arrives as one structured briefing instead of scattered intermediate responses.
• Safer expansion path: asynchronous task handling gives more room for richer agent workflows later without forcing every request into a blocking pattern.

Practical Example 1: Build a Dollar Briefing Before a Fed Day

Imagine you want a fast briefing on the dollar before a major Federal Reserve decision. The goal is not a full research report. The goal is a compact packet you can review quickly: supported indicators, latest policy level, latest GDP print, and the next scheduled releases that could reshape the narrative.

You can inspect the underlying source data directly through the API first. For example, here is a simple pull for the current US policy-rate series:

curl "https://fxmacrodata.com/api/v1/announcements/usd/policy_rate?api_key=YOUR_API_KEY"

A representative response looks like this:

{
  "ok": true,
  "status_code": 200,
  "result": {
    "currency": "USD",
    "indicator": "policy_rate",
    "data": [
      {
        "date": "2025-12-01",
        "val": 4.5,
        "announcement_datetime": "2025-12-17T19:00:00Z"
      },
      {
        "date": "2026-03-01",
        "val": 4.25,
        "announcement_datetime": "2026-03-18T18:00:00Z"
      }
    ]
  }
}

That is useful on its own, but the new MCP task workflow is designed for the next step: combine that rate information with GDP, available indicator coverage, and upcoming releases automatically. Instead of manually coordinating several lookups, a task-capable client can ask for one macro briefing and wait for the assembled result.

The practical interpretation is straightforward: before a Fed day, you can offload the repetitive prep work and focus on what matters next, such as whether the rate path, growth profile, and upcoming schedule still support the prevailing dollar narrative.

Practical Example 2: Start an MCP Task and Poll the Result

For MCP clients that support Tasks, the new flow looks like this: start the task, receive a task record immediately, poll status, then fetch the result after completion.

A simplified create request over the MCP endpoint might look like this:

curl "https://fxmacrodata.com/mcp?api_key=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "macro_briefing_task",
      "arguments": {
        "currency": "usd"
      },
      "task": {
        "ttl": 60000
      }
    }
  }'

A representative immediate response would be:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "task": {
      "taskId": "4f2d6bb6-5f8d-4b39-a3a4-b1f56cb0f8c9",
      "status": "working",
      "createdAt": "2026-05-25T16:40:00Z",
      "lastUpdatedAt": "2026-05-25T16:40:00Z",
      "ttl": 60000,
      "pollInterval": 500
    },
    "_meta": {
      "io.modelcontextprotocol/model-immediate-response": "Preparing a macro briefing task for USD."
    }
  }
}

After that, the client polls the task state and then requests the final payload:

{
  "taskId": "4f2d6bb6-5f8d-4b39-a3a4-b1f56cb0f8c9",
  "status": "completed",
  "result": {
    "structuredContent": {
      "currency": "USD",
      "latest_policy_rate": {"val": 4.25},
      "latest_gdp": {"val": 2.1},
      "next_releases": [
        {"indicator": "inflation", "announcement_datetime": "2026-06-12T12:30:00Z"},
        {"indicator": "retail_sales", "announcement_datetime": "2026-06-17T12:30:00Z"}
      ]
    }
  }
}

From a trading perspective, this is useful because the client gets a concise packet it can act on immediately: what the current macro stance looks like, what the most recent growth print says, and which releases may invalidate the view next.

Where Tasks Fit Alongside MCP Visualizations

The Tasks release sits naturally beside the new visualization capability. Visual tools help when you need to see shape and regime. Tasks help when you need to orchestrate a multi-step research job and receive the answer as one coherent result.

Together, that gives agent builders two important building blocks:

• visual inspection for charts, comparisons, and fast interpretation;
• asynchronous execution for multi-call workflows that should not block the session.

In practical terms, an agent can now decide whether a job should be rendered, summarized, or delegated to a tracked background task depending on what the user asked for.

What the First Task-Capable Tool Does

The initial task-enabled tool is intentionally narrow. It builds a compact macro briefing for a single currency. That keeps the workflow easy to reason about while still being useful in live prep.

The completed result includes:

• the requested currency;
• catalogue context for supported indicators;
• the latest policy-rate observation;
• the latest GDP observation;
• the next few scheduled releases.

This is not meant to replace deeper analysis. It is meant to reduce the time between “give me the current macro setup” and “I have enough structured context to decide what to watch next.”

Get Started

If your MCP host supports Tasks, you can start using the new flow immediately with macro_briefing_task. If not, the same tool still works synchronously, so the feature degrades cleanly instead of forcing a separate integration path.

To explore the feature, connect to the FXMacroData MCP server, request a briefing for a currency, and compare the synchronous and task-augmented flows. If you want to inspect the underlying data, start with the policy-rate docs and the FXMacroData MCP server documentation.