Skip to main content
Runtime Labs is building the temporal runtime layer for intelligent systems — where plans, memory, and agent behavior are grounded in time. Our infrastructure transforms calendars into programmable execution environments that support planning, feedback, and learning over time. We enable agents to act in alignment with real-world constraints, commitments, and context—by embedding structured memory and scheduling directly into the interface between users and models.
To get started, head to the Quickstart Guide.
Time remains a missing primitive in modern model architectures. Runtime Labs addresses this by introducing time as a first-class interface:
  • Memory traces encode events, reflections, and tasks
  • Calendars serve as the medium for agent scheduling and feedback
  • Agent runtimes manage planning, execution, and adaptation
We’re developing a modular stack that brings these components together into a coherent system.

​
Chronologue: Entry Point to the Runtime

Chronologue connects natural language interfaces to calendar-based scheduling. It allows users to prompt agents, create structured events, and reflect on past actions through:
  • Memory Traces — JSON records of plans, reflections, and goals
  • Calendar Integration — .ics sync with Google and Apple calendars
  • Promptable Interface — Interact via chat, tables, or calendar views
  • Agent Control — Steerable agents that act only with user approval
Use Chronologue to:
  • Generate and update calendar events with natural language
  • Retrieve past memory traces to reflect or reschedule
  • Sync plans and feedback into external calendars
  • Maintain agency over what agents propose, execute, and learn

​
Principles

Runtime Labs is built on three principles:
  1. Temporal grounding: Intelligence must align with real-world time, commitments, and durations.
  2. User autonomy: Users remain in control—agents propose, users approve.
  3. Memory continuity: Long-term reasoning requires persistent, structured memory traces.
This philosophy informs both our UX and system architecture, aligning language models with real-world workflows.

​
Research Questions

How accurately can language models estimate how long a user-specific task will take?
  • Model task durations conditioned on user history, task type, and past behavior
  • Represent grounded time estimates with distributions (mean, variance, confidence)
  • Use predicted durations to improve calendar slotting and adaptive scheduling
How should structured memory traces (e.g., JSON event logs) be serialized and embedded to preserve temporal and semantic structure?
  • Design temporal tokens (e.g., <tempo:2024-05-08T09:00Z>) for model prompts
  • Evaluate serialization formats that maintain chronological order and task dependencies
  • Measure downstream effects on grounding fidelity and model coherence
What are effective strategies for compressing or prioritizing long-term memory traces for in-context planning?
  • Compare summarization techniques
  • Develop ranking methods based on recency, recurrence, and user interactions
  • Align summarization granularity with planning horizon and task duration
How can agent behavior improve over time based on user feedback?
  • Learn preferences from edits, rejections, and scheduling patterns
  • Dynamically adapt retrieval and suggestions based on evolving user behavior
Cursor Calendar is a prototype that integrates a chat interface directly into the calendar runtime.
  • Supports generation, retrieval, and updates using natural language and memory traces
  • Demonstrates steerable agent behavior and schedule-aware reasoning
  • Syncs with .ics files and Google Calendar for live feedback
CursorCalendar Screenshot

Google Calendar Sync

Set up Google Calendar synchronization.

iCalendar Sync

Set up iCalendar synchronization.

MCP Integration

Integrate with Model Context Protocol (MCP) server.

Datasets

Explore sample datasets and example workflows and schema.
Chronologue is open source. Explore the codebase on GitHub.
We welcome contributions and feedback to Chronologue and make the code available to the community.
⌘I