Turning an Idea into Reality: How We Built Natural Language Time Logging in Days

How It Started

It began with a casual conversation between a consultant and a customer who already had a solid time tracking tool. The interface was clean, actions were quick, and the team liked using it, yet people still dreaded logging time. The issue wasn’t the UI but the constant context switching: pausing work, looking up Jira issues, double-checking task names, picking dates, and entering all details manually. The tool didn’t help them remember what they worked on: it expected them to know. That’s when our consultants asked: “What if you could just tell the system what you worked on, and it handled the rest?” Saying something like “Log two hours yesterday on debugging authentications after lunch,” or “Add four billable hours for monday morning to DEV-456,” and having the time entry created automatically immediately showed value: no issue key hunting, no screen jumping, no mental gymnastics.

Enter the Model Context Protocol

When the idea reached our development team, the question wasn’t whether we could build it but how fast we could deliver a working prototype. The backend functionality was already there; STAGIL Timetracker has a REST API. What was missing was a translator between the API, the context inside Atlassian tools, and external AI assistants. The solution came in the form of the Model Context Protocol (MCP), an open standard by Anthropic. MCP acts as a universal translator between AI models and the systems they need to interact with, allowing AI assistants to discover tools, understand capabilities, and execute them with proper parameters. It’s protocol-agnostic, so it works with any MCP-compatible assistant, including Claude, ChatGPT, and future AI platforms. By building an MCP server wrapping the Timetracker API, we exposed time logging as tools AI could understand, leveraging the existing API without changing the core system and keeping a clean separation between AI and business logic.

The Power of Integration

Building an Extensible Architecture

From the start, we designed the system to be modular and reusable. If natural language time logging works for one customer, it will be valuable for others. And if we can make time logging accessible via natural language, other areas like project management, resource allocation, or reporting could also benefit. The building blocks we created can be adapted to different APIs and authentication methods. The time logging implementation itself handles the complexity of converting natural language into structured data: understanding durations (“two hours”), resolving relative dates (“yesterday”), identifying the correct project or work item, and packaging everything in the format the API expects. With Atlassian MCP, users don’t even need to know the work item key; they just describe their work, and the AI handles the rest automatically.

Solving Temporal Understanding

One of the trickiest parts was temporal understanding. When a user says “yesterday” or “next Monday,” the AI must resolve these to actual calendar dates, accounting for time zones and the context of “now,” which language models normally lack. We built two complementary tools: get_current_datetime, which provides AI with the full temporal context including ISO-8601 dates, day and week numbers, and Unix timestamps; and check_date, which validates and resolves date expressions before taking action, returning fully resolved temporal data. This ensures worklogs are created for the correct dates and prevents errors from ambiguous references. Both tools use the Temporal API (temporal-polyfill) for robust, timezone-aware handling, even across daylight saving transitions.

The MCP Server Implementation

The MCP server is built on Next.js, exposing an HTTP endpoint that handles JSON-RPC requests following the MCP specification. Next.js allows serverless deployment on AWS Lambda or similar platforms, while making the server publicly accessible for AI assistants in different environments. The server follows a clean request-response pattern: AI assistants first initialize to learn server capabilities, then discover available tools with schemas describing parameters, types, and usage, and finally execute tools with proper routing and error handling. This architecture ensures maintainability, reliability, and clear communication between AI and the system.

Rapid Prototyping with Agentic AI

The speed of development was remarkable. Using agentic AI coding tools, we moved from concept to working prototype in days. The tools helped generate boilerplate code, type-safe API clients, schemas, validation logic, and error handling, suggested architectural improvements, and enabled rapid iteration. They allowed immediate testing and adjustment when edge cases appeared, ensuring a smooth development process without weeks of planning or manual coding.

The Power of Quick Reaction Time

AI-assisted development changed how we deliver solutions. When a consultant surfaces a real pain point, our response isn’t analysis alone, it’s action too. Prototyping has become core to innovation, letting us test assumptions early, make decisions based on real interactions, and quickly deliver value. This improves both internal collaboration and the speed at which insights become usable solutions for customers.

Looking Forward

The prototype demonstrates how combining existing APIs with AI interfaces can make time tracking intuitive. Users can describe work naturally, without forms or context switching. The architecture can extend to other STAGIL products or systems, enabling task creation, updates, assignments, and reporting. Integration with Atlassian MCP highlights MCP’s composability: multiple specialized servers orchestrate workflows more intelligently than any single integration. Most importantly, it proves how quickly an idea can become a working solution. A casual question became a prototype that is already transforming how teams engage with time tracking.