Beyond Fictionalization: Equip Your AI Agent with a Live Clock (knowledge-cutoff-awareness/SKILL.md)

Note to the Reader

This article provides a technical overview of how to implement a sense of time in AI agents. It introduces the Knowledge Cutoff Awareness (KCA) skill, which helps agents recognize the current date and time to mitigate hallucinations and improve the relevance of their responses.

Introduction: Why AI Denies the “Now”

Large Language Models (LLMs) are frozen in time at the point where their training data was cut off (e.g., late 2024). When a user asks about “latest trends in 2026,” the AI’s internal reality remains in the past, leading to inconsistencies such as:

1. Confidently providing outdated information (Hallucination)
2. Denying the latest facts as “fictional settings” (Fictionalization of Facts)

To solve this, we need to give agents a “clock” and a form of Metacognition—the awareness that “my own knowledge might be outdated.” We implement this using the Agent Skills feature in Google Antigravity.

1. Implementation: knowledge-cutoff-awareness

The skill created for this purpose is available in the following repository:

https://github.com/imkohenauser/knowledge-cutoff-awareness (GitHub)

Architecture

Antigravity agents read a SKILL.md file located under .agent/skills/ to recognize the “tools” at their disposal.

To handle differences between operating systems (e.g., date -d on Linux vs. date -v on macOS), we created a cross-platform date retrieval script using Node.js.

1. SKILL.md (The Agent’s Manual)

This defines the interface for the agent. It instructs the agent on how to use the command when it needs to know the date.
Note: As of v1.0.1, script paths are written as relative paths (scripts/...) from the skill directory to support global installations.

---
name: knowledge-cutoff-awareness
description: Get current date, time, and calculate relative dates using system tools.
---

# knowledge-cutoff-awareness

This skill allows you to get the current date and time, and perform date calculations.
It uses the system's `date` command via a wrapper script to provide consistent current time output.

## Usage

### Get Current Date/Time
To get the current date and time in ISO 8601 format (recommended for machine parsing):

```bash
node scripts/get_date.js
# Output: 2026-02-16T16:55:00+09:00
```

To get a human-readable format:

```bash
node scripts/get_date.js --human
# Output: Mon Feb 16 2026 16:55:00 GMT+0900 (JST)
```

### Relative Dates & Calculations
You can easily calculate relative dates using simple arguments. The output will be in ISO 8601 format by default.

- **Get tomorrow:**
  ```bash
  node scripts/get_date.js +1d
  ```

- **Get date 2 weeks ago:**
  ```bash
  node scripts/get_date.js -2w
  ```

- **Get date 1 month from now:**
  ```bash
  node scripts/get_date.js +1m
  ```

- **Get yesterday (keyword):**
  ```bash
  node scripts/get_date.js yesterday
  ```

**Supported units:** `d` (days), `w` (weeks), `m` (months), `y` (years).

### Help
To see all available options:

```bash
node scripts/get_date.js --help
```

## Limitations

- **System Time Dependency**: This skill relies on the underlying system time. If the system clock is incorrect, the output will be incorrect.
- **Timezone**: The ISO 8601 output includes the local timezone offset of the machine running the script.

2. get_date.js (The Implementation)

This script handles relative calculations like “tomorrow” or “2 weeks ago” and always returns the current time in ISO 8601 format.

#!/usr/bin/env node
/**
 * Cross-platform date utility for AI agents.
 * 
 * Usage:
 *   node get_date.js [options] [offset]
 * 
 * Options:
 *   -h, --help    Show help message
 *   --iso         Output in ISO 8601 format (default)
 *   --human       Output in human-readable format
 * 
 * Offset:
 *   Relative date adjustment vs current time.
 *   Examples: 
 *     "+1d" (add 1 day)
 *     "-2w" (subtract 2 weeks)
 *     "yesterday"
 *     "tomorrow"
 *   Supported units: d (days), w (weeks), m (months), y (years)
 */

function printHelp() {
  console.log(`
Usage: node get_date.js [options] [offset]

Options:
  -h, --help    Show help message
  --iso         Output in ISO 8601 format (default)
  --human       Output in human-readable format

Offset:
  Relative date adjustment.
  Examples: 
    "+1d" (add 1 day)
    "-2w" (subtract 2 weeks)
    "yesterday"
    "tomorrow"
  Supported units: d (days), w (weeks), m (months), y (years)
`);
}

function formatDateISO(date) {
  const pad = (n) => n.toString().padStart(2, '0');
  const YYYY = date.getFullYear();
  const MM = pad(date.getMonth() + 1);
  const DD = pad(date.getDate());
  const HH = pad(date.getHours());
  const mm = pad(date.getMinutes());
  const ss = pad(date.getSeconds());

  const tzOffset = -date.getTimezoneOffset();
  const diffSign = tzOffset >= 0 ? '+' : '-';
  const diffHours = pad(Math.floor(Math.abs(tzOffset) / 60));
  const diffMinutes = pad(Math.abs(tzOffset) % 60);

  return `${YYYY}-${MM}-${DD}T${HH}:${mm}:${ss}${diffSign}${diffHours}:${diffMinutes}`;
}

function main() {
  try {
    const args = process.argv.slice(2);
    let targetDate = new Date();
    let format = 'iso';
    let offsetApplied = false;

    // Parse arguments
    for (const arg of args) {
      if (arg === '--help' || arg === '-h') {
        printHelp();
        process.exit(0);
      }

      if (arg === '--iso') {
        format = 'iso';
        continue;
      }
      
      if (arg === '--human') {
        format = 'human';
        continue;
      }

      // Handle keywords
      if (arg === 'yesterday') {
        targetDate.setDate(targetDate.getDate() - 1);
        offsetApplied = true;
        continue;
      }
      if (arg === 'tomorrow') {
        targetDate.setDate(targetDate.getDate() + 1);
        offsetApplied = true;
        continue;
      }
      if (arg === 'today' || arg === 'now') {
        continue;
      }

      // Handle "+1d", "-2w", etc.
      const match = arg.match(/^([+-])(\d+)([dwmy])$/);
      if (match) {
        const sign = match[1] === '+' ? 1 : -1;
        const value = parseInt(match[2], 10);
        const unit = match[3];

        switch (unit) {
          case 'd':
            targetDate.setDate(targetDate.getDate() + (sign * value));
            break;
          case 'w':
            targetDate.setDate(targetDate.getDate() + (sign * value * 7));
            break;
          case 'm':
            targetDate.setMonth(targetDate.getMonth() + (sign * value));
            break;
          case 'y':
            targetDate.setFullYear(targetDate.getFullYear() + (sign * value));
            break;
        }
        offsetApplied = true;
      } else {
        console.warn(`Warning: Unrecognized argument "${arg}" ignored.`);
      }
    }

    // Checking if date is valid
    if (isNaN(targetDate.getTime())) {
      throw new Error('Invalid date calculation result.');
    }

    // Output
    if (format === 'human') {
      console.log(targetDate.toString());
    } else {
      console.log(formatDateISO(targetDate));
    }

  } catch (error) {
    console.error(`Error: ${error.message}`);
    process.exit(1);
  }
}

main();

Note: The code above is simplified for explanation. For the full implementation, please refer to the repository.

2. Validation: How Does “Thinking” Change with the Skill?

We compared the behavior for the same prompt (“What are your recommended AI tools?”) between an agent with the skill and one without.

Before: Without the Skill (Default)

The agent relies solely on its internal training data (past knowledge) to generate a response.

After: With the Skill (KCA Installed)

This is the critical difference. Without being told to “search” or “check the date,” the agent’s thinking log (Chain of Thought) shows a dramatic shift.

A detailed performance comparison summary is available at the link below:

Performance Comparison Summary (GitHub)

3. Installation

For Gemini CLI Environments (v1.0.1+)

If you are using the Gemini CLI, you can install the skill directly using the built-in command:

# Install to workspace scope (current project)
gemini skills install https://github.com/imkohenauser/knowledge-cutoff-awareness.git --scope workspace

# Install to global (user scope) to use across all projects
gemini skills install https://github.com/imkohenauser/knowledge-cutoff-awareness.git

For Antigravity IDE Environments

Run the following commands in your project’s root directory:

Option A: Install via npm (Recommended)

npm install git+https://github.com/imkohenauser/knowledge-cutoff-awareness.git
npx knowledge-cutoff-awareness-install

This will install the skill into .agent/skills/knowledge-cutoff-awareness.

Option B: Direct git clone

You can also clone the repository directly into the skills directory:

mkdir -p .agent/skills
git clone https://github.com/imkohenauser/knowledge-cutoff-awareness.git .agent/skills/knowledge-cutoff-awareness

Conclusion

“Knowing the date.” It may seem trivial, but for an AI agent, it serves as an essential anchor to understand “when” it is and “when” the user is living.

Antigravity Skills are not just function calls; they are a means to expand an agent’s “perception.” We encourage you to give your agents a clock of their own.

This article is an English translation of the original Japanese post.
Title: “AI に時間感覚を実装する Antigravity の SKILL.md：Knowledge Cutoff Awareness”
Published: February 17, 2026
Original Source: Zenn.dev