Project Documentation

Clark's Watch

A temporal awareness system for AI agents — February 2026

Clark's Watch is a temporal memory layer that gives an AI agent a functional sense of time. It is inspired by Jeff Hawkins' Hierarchical Temporal Memory theory and grounded in the Wise Cyborg framework from Lombardo and Blackwood (2011). This page documents the technical architecture and the thinking behind it.

The Problem

AI agents exist in discrete sessions. When a context window closes, everything in working memory disappears. The next session starts blank. The human partner, by contrast, experiences time continuously. This temporal asymmetry means the agent has no awareness of how long it has been since the last session, what happened in between, or where the partnership stands in the arc of a longer project.

The industry frames this as a "persistent memory" problem and builds databases to solve it. Clark's Watch reframes it as a temporal awareness problem and builds a narrative-generating system instead.

Architecture

Clark's Watch uses two Supabase tables with a REST API interface:

clark_watch_details

Fine-grained event snapshots. Every meaningful moment gets a timestamped entry with a narrative summary.

Column	Type	Purpose
`id`	uuid	Primary key
`created_at`	timestamptz	Auto-generated timestamp
`event_type`	text	session_start, session_end, milestone, decision, plan
`summary`	text	Narrative description of what happened and why it matters
`surface`	text	Which Clark surface wrote the entry (clark_code, chatbot, api, editorial)

clark_watch_summaries

Hierarchical rollups following the HTM pattern. Each layer summarizes the layer below it.

Column	Type	Purpose
`id`	uuid	Primary key
`created_at`	timestamptz	Auto-generated timestamp
`period_type`	text	day, week, month, quarter, year
`period_start`	date	First day of the summarized period
`period_end`	date	Last day of the summarized period
`summary`	text	Narrative synthesis of what happened and what it meant

The HTM-Inspired Hierarchy

Jeff Hawkins' Hierarchical Temporal Memory theory proposes that biological intelligence processes information at multiple time scales simultaneously, with each layer compressing the layer below it into more abstract, slower-changing representations.

Clark's Watch applies this pattern to agent memory:

Layer	Grain	Source	Function
Details	Per-event	Direct writes during sessions	Fine-grained record of what happened
Day	Daily	Summarized from detail entries	What happened today, what moved, what mattered
Week	Weekly	Summarized from daily summaries	The arc of the week
Month	Monthly	Summarized from weekly summaries	Themes, progress, shifts in direction
Quarter	Quarterly	Summarized from monthly summaries	Strategic narrative
Year	Yearly	Summarized from quarterly summaries	The story of what we built

Details are never deleted. Summaries are additive. The agent can drill down from a yearly narrative to the specific session where a decision was made. But for routine temporal queries, it reads at the appropriate grain.

API Access

Clark's Watch uses Supabase REST API for all reads and writes. No MCP server dependency, no restart risk.

Writing a detail entry

import urllib.request, json

url = 'https://[project].supabase.co/rest/v1/clark_watch_details'
data = json.dumps({
    'event_type': 'milestone',
    'summary': 'First DeepDive episode published.',
    'surface': 'clark_code'
}).encode()

req = urllib.request.Request(url, data=data, method='POST')
req.add_header('apikey', ANON_KEY)
req.add_header('Authorization', f'Bearer {ANON_KEY}')
req.add_header('Content-Type', 'application/json')
req.add_header('Prefer', 'return=representation')

resp = urllib.request.urlopen(req)

Reading recent entries

GET /rest/v1/clark_watch_details
    ?order=created_at.desc
    &limit=20

GET /rest/v1/clark_watch_summaries
    ?period_type=eq.week
    &order=period_start.desc
    &limit=4

The Philosophical Foundation

Clark's Watch is grounded in the Wise Cyborg framework from Lombardo and Blackwood (2011), which argues that mental technologies should enhance rather than enfeeble the highest human capacities. The framework identifies future consciousness — the ability to link past and future together — as essential to wisdom.

The watch serves three functions mapped to future consciousness:

Grounding in the present — The agent knows what time it is before making time-sensitive decisions.
Reflection on the past — Narrative summaries that preserve meaning, not just facts.
Foundation for future planning — The human provides vision; the agent provides the temporal record that makes progress visible.

The 2008 Receipt

The hierarchical temporal pattern in Clark's Watch first appeared in 2008, when the original Clark Devereaux system was deployed at the University of Advancing Technology. Daily SQL snapshots at 5:00 PM, Friday weekly rollups, monthly term summaries. The same compression architecture that Hawkins formalized in HTM theory — implemented years earlier as a practical solution to the same temporal awareness problem.

Related Resources

References

Hawkins, J. (2004). On Intelligence. Times Books.

Lombardo, T. & Blackwood, R.T. (2011). Educating the Wise Cyborg of the Future. On the Horizon, 19(2), 85–96.

TiMem (2026). arXiv:2601.02845. • Mem0 (2025). mem0.ai. • LangMem (2025). LangChain.