Claude doesn't know your deadline is Friday. GPT can't tell you two meetings overlap. Your copilot has no concept of "this task takes 8 hours." Every session ignores time.
The current fixes don't work. Calendar APIs are read-only silos -- you get events, never "how long will this really take?". Markdown TODO lists have no temporal structure -- no dependencies, no decay, no confidence. Reminder apps are flat -- no sequences, no PERT estimates, no conflict detection.
Temporal reasoning for AI agents — deadlines, schedules, sequences, duration estimation (PERT), and decay models. One .atime file. Rust core + MCP server.
星數
4
工具
—
可用率
—
AgenticTime gives your agent structured temporal reasoning in a single binary file. Not "set a timer." Your agent has a timeline -- deadlines, schedules, sequences, duration estimates, and decay curves -- all persisted, all queryable in microseconds.
Problems Solved (Read This First)
Problem: deadlines vanish between conversations.
Solved: persistent .atime file survives restarts, model switches, and long gaps between sessions.
Problem: no way to detect schedule conflicts.
Solved: automatic overlap detection for all scheduled events with priority-aware resolution.
Problem: duration estimates disappear with no feedback loop.
Solved: PERT estimation with confidence intervals; actuals tracked against estimates.
Problem: multi-step workflows have no temporal structure.
Solved: sequences model ordered steps with dependency constraints and status tracking.
Problem: all information weighted equally regardless of age.
Solved: four decay models (linear, exponential, half-life, step) quantify freshness.
Problem: timeline state bleeds between projects.
Solved: per-project .atime files with path-based isolation.
Rust core. Zero-copy access. Real numbers from Criterion statistical benchmarks:
Operation
Time
Scale
Add deadline
0.02 ms
100 entities
List deadlines
0.05 ms
100 entities
Conflict detection
0.1 ms
100 entities
List deadlines
0.4 ms
1K entities
Conflict detection
0.8 ms
1K entities
List deadlines
3.8 ms
10K entities
Conflict detection
7.2 ms
10K entities
Decay query
0.001 ms
any scale
Save file
28 ms
10K entities
All benchmarks measured with Criterion (100 samples) on Apple M4 Pro, 64 GB, Rust 1.90.0 --release.
Capacity: A year of daily use produces a small .atime file. Designed for multi-year project tracking without growth concerns.
Calendar API
Markdown TODOs
Reminder Apps
AgenticTime
Conflict detection
Limited
None
None
Automatic
Duration estimation
None
None
None
PERT + confidence
Decay models
None
None
None
4 models
Sequence dependencies
None
Manual
None
First-class
Portability
Vendor-locked
File-based
App-locked
Single file
External dependencies
Cloud service
None
Cloud service
None
MCP-native
No
No
No
Yes
Why AgenticTime
Time is structure, not a flat list. When you plan a project, you need sequences with dependencies, deadlines with priorities, schedules with conflict detection, and duration estimates with confidence. That's temporal reasoning. A TODO list can never provide this.
One file. Truly portable. Your entire timeline is a single .atime file. Copy it. Back it up. Version control it. No cloud service, no API keys, no vendor lock-in.
Any LLM, any time. Start with Claude today. Switch to GPT tomorrow. Move to a local model next year. Same temporal file.
Five entity types. Deadlines, schedules, sequences, duration estimates, and decay curves. Each modeled with domain-specific semantics -- not generic key-value pairs.
Downloads a pre-built agentic-time-mcp binary to ~/.local/bin/ and merges the MCP server into your Claude Desktop and Claude Code configs. Requires curl and jq.
If release artifacts are not available, the installer automatically falls back to cargo install --git source install.
Environment profiles (one command per environment):
# Desktop MCP clients (auto-merge Claude Desktop + Claude Code when detected)
curl -fsSL https://agentralabs.tech/install/time/desktop | bash
# Terminal-only (no desktop config writes)
curl -fsSL https://agentralabs.tech/install/time/terminal | bash
# Remote/server hosts (no desktop config writes)
curl -fsSL https://agentralabs.tech/install/time/server | bash
Standalone by default: AgenticTime is independently installable and operable. Integration with AgenticMemory or other sisters is optional, never required.
Per-project isolation by default: each project gets its own .atime file.
Any MCP-compatible client gets instant access to structured temporal reasoning. The agentic-time-mcp crate exposes the full AgenticTime engine over the Model Context Protocol (JSON-RPC 2.0 over stdio).
cargo install agentic-time-mcp
Configure Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
Once connected, the LLM can manage deadlines, detect schedule conflicts, track duration estimates, step through sequences, and query decay curves -- all backed by the same .atime binary file. Full MCP docs ->
Quickstart
MCP agent -- natural language
After install and MCP client restart, ask your agent:
Set a deadline for "finish API review" on Friday at 5pm
The agent calls time_deadline_add and persists it to your .atime file.
How long will the auth refactor take?
The agent calls time_duration_estimate with confidence intervals.
Schedule a 2-hour code review every Tuesday at 10am
The agent calls time_schedule_add with recurrence.
What's on my timeline this week?
The agent calls time_deadline_list and time_schedule_list to show upcoming commitments.
Multi-step workflows -- Sequences model deployment pipelines:
atime sequence create "deploy-v1" --steps "build,test,stage,prod"
atime sequence step "deploy-v1" # advance to next step
How It Works
AgenticTime models temporal data through five entity types in a custom binary format. Each entity has domain-specific semantics. The file is portable across models, clients, and deployments.
The core runtime is written in Rust for performance and safety. All state lives in a portable .atime binary file -- no external databases, no managed services. The MCP server exposes the full engine over JSON-RPC stdio.
The five entity types in detail:
Type
What
Example
Deadline
Fixed point in time with priority and consequence
"Ship v1.0 by March 15, high priority"
Schedule
Recurring or one-time calendar block
"Code review every Tuesday at 10am, 2 hours"
Sequence
Ordered chain of steps with dependencies
"build -> test -> stage -> prod"
Duration
Estimated time span with PERT confidence
"Auth refactor: 8h estimated, 0.7 confidence"
Decay
Function modeling information freshness
"Exponential decay, half-life = 168 hours"
Decay models -- four types: linear . exponential . half_life . step
The binary .atime file uses fixed-size records (O(1) access), LZ4-compressed content, and memory-mapped I/O. No parsing overhead. No external services. Instant access.