Show HN: An MCP server that gives LLMs temporal awareness and time calculation (github.com)

I am curious: You say "offline-first or local-first, quantified self projects", what models do you use with your projects?

I find the LLMs like the Claude and GPT families to be incredibly impressive for integration and metacognition — however, I am not sure yet what LMs are best for that purpose, if there are any.

Your "Augmented Awareness" framework seems to be metacognition-on-demand. In practice, how has it helped you recently? Is it mostly automated, or does it require a lot of manual data transfers?

I am assuming that the MCP server is plugged into a model, and that in the model you run prompts to run retrospectives.

Have you written about this?

With an MCP server the model can call now(), diff it against earlier turns, and notice: "you were away 3 h, shall I recap?" or "deadline is 18 h out, let’s prioritise". That continuous sense of elapsed time simply isn’t possible with a static timestamp stuffed into the initial prompt; you'd have to create a new chat to update the time, and every fresh query would require re‑injecting the entire conversation history. MCP gives the model a live clock instead of a snapshot.

But for the broader question: I see sycophancy as a double‑edged sword.

• On one side, the Dunning–Kruger effect shows that unwarranted praise can reinforce over‑confidence and bad decisions.

• On the other, chronic imposter syndrome is real—many people underrate their own work and stall out. A bit of positive affect from an LLM can nudge them past that block.

So the issue isn't "praise = bad" but dose and context.

Ideally the model would:

1. mirror the user's confidence level (low → encourage, high → challenge), and

2. surface arguments for and against rather than blanket approval.

That's why I prefer treating politeness/enthusiasm as a tunable parameter—just like temperature or verbosity—rather than something to abolish.

In general, these all-or-nothing, catastrophizing narratives in AI (like in most places) often hide very interesting questions.

At the same time I understand what you mean and I agree that no, this does not give any LLM any sense of anything, in the same way that we conceive it. But it provides them context with take for granted in service of further customizing their outputs.

Your "calendar" is nice, thanks for sharing. :)

You’re right: Stripping away all ambient context is both a bug and a feature. It lets us rebuild “senses” one at a time—clean interfaces instead of the tangled wiring in our own heads.

Pauses are the first step, but I’m eager to experiment with other low‑bandwidth signals:

• where the user is (desk vs. train) • weather/mood cues (“rainy Sunday coding”) • typing vs. speech (and maybe sentiment from voice) • upcoming calendar deadlines

If you could give an LLM just one extra sense, what would you pick—and why?

But there are some issues:

1. Cheaper + Deterministic: It is much more costly, both in terms of tokens and context window. (Generating the code takes many more tokens than making a tool call.) And there can be variability in the query, like issues with timezones.

2. Portability: It is not portable, not all LLM or LM environments have access to a code interpreter. This is a much lower resource requirement.

3. Extensibility: This approach is extensible, and it allows us to expand the toolkit with additional cognitive scaffolds that help contextualize how we experience time for the model. (This is a fancy way of saying: The code only gives the timestamp, but building an MCP allows us to contextualize this information — "this is time I'm sleeping, this is the time I'm eating or commuting, etc.")

4. Security: Ops teams are happier approving a read-only REST call than arbitrary code running.

In practice, this hasn't really worked. I've had to add a custom instruction to "call current_datetime" at each message to get Claude to do it consistently over time.

Still, it is meaningful that I ask the model to make a single quick query rather than generate code.

1. *Hands‑free integration*: ChatGPT, Claude, etc. don’t let you auto‑append text, so you have to manually do it. Here, a server call happens behind the scenes—no copy‑paste or browser hacks.

2. *Math & reliability*: LLMs core models are provably not able to do math (without external tools), this is a theoretical limitation that will not change. The server not only returns now() but also time_difference(), time_since(), etc., so the model gets ready‑made numbers instead of trying to subtract 1710692400‑1710688800 itself.

3. *Extensibility*: Time is just one "sense." The same MCP pattern can stream location, weather, typing‑vs‑dictation mode, even heart‑rate. Each stays a compact function call instead of raw blobs stuffed into the prompt.

So the tool isn’t about fancy code—it’s about giving the model a live, scalable, low‑friction sensor instead of a manual sticky note.