Changelog

When a contractor bills a firm, the same invoice lives three lives: a spreadsheet on the contractor’s laptop, a bill in the firm’s payables tool, and a line in the accountant’s ledger. Each copy is re-keyed by hand, and none of them knows what the others are doing. The contractor never learns the bill was scheduled; the firm never sees the hours behind the amount.

Bill.com closes that loop. Connect the Bill.com account you invoice from, map each client to a Bill.com customer, and Sync to Bill.com on any TimeSentry invoice sends it through Bill.com with the PDF attached. Clients already on the BILL network receive it as an eBill in their Bill.com inbox; everyone else gets the emailed invoice with a payment link. As Bill.com schedules and clears the payment, the invoice in TimeSentry moves from sent to scheduled to paid on its own.

For agencies and firms that pay contractors through Bill.com, the payoff is on the receiving end. Invoices addressed to you now appear in your payables tab the moment the contractor sends them, whether or not they have a project set up on your side. If your firm also connects its Bill.com, the bill that lands in your inbox links back to that same invoice, so both parties are looking at one record with one status. And because Bill.com keeps syncing to QuickBooks as before, the QuickBooks pull recognizes the round-tripped bill as the invoice it already knows instead of creating a duplicate vendor and a second payable.

Mapping stays explicit: TimeSentry suggests the matching customer by email or name, but never guesses on your behalf, and it never moves money. Bill.com pays, your accounting system keeps the books, and TimeSentry is where the work and the invoice agree.

A staffing plan that ignores vacations is a plan that lies for two weeks every summer. The seat is filled, the hours are budgeted, the client dashboard is green — and the person is on a beach. Until now the only way to see that was to remember it.

Vacations is a new tab under Staffing. Record time off — vacation, holiday, leave — and it shows up on every coverage view as a hatched texture inside the planned hours: a role that is 92% staffed but 20% away now says exactly that. Role budgets, the allocation grid, and the staffing timeline all draw the same hatch, so an unfilled seat and a filled-but-absent one never look alike again. Nothing about the plan itself changes: budgets, allocations and utilization stay as you set them. Time off is an overlay, not a deduction.

Two ways to add it, deliberately kept apart:

• For yourself. Add your own time off once, from your own workspace, and it follows you to every firm you work for — each of them sees it on their staffing views, and only you can change it. For contractors and fractional staff spread across several clients, this replaces telling five people the same dates.
• For a team member. Firms record absences for their staff on their own books, with a twelve-week out-of-office grid to plan around.

Coverage is measured the way planners think about it — by the working week. A three-day break counts as three-fifths of that week’s hours away, whichever day you look.

For agencies and firms staffing retainers, this is the difference between discovering a gap on Monday morning and seeing it a month out.

TimeSentry has always read your workday to draft your timesheet: sent emails, meetings, and calls become suggested time entries you review and approve. But those same sources carry a second signal we were throwing away — the work you haven’t done yet. A client asking for a revised engagement letter. An action item assigned to you in a meeting. A request buried in a Slack thread.

Automated task capture turns that signal into a task list. Opt in, and an hourly pass reads your chosen sources — inbox, chat, meeting transcripts, uploaded documents — and creates AI-suggested tasks wherever something actionable appears. Each suggestion arrives review-ready, exactly like suggested time entries: a confidence score, an AI-assigned project, and a link back to the email or meeting it came from. Keep it or dismiss it in one click, on web or with a swipe on mobile.

The sources are yours to choose, and they’re deliberately separate from time capture. Time entries read your sent mail — work you did. Task capture defaults to your inbox — things asked of you. Two different questions, two different configurations.

Two more pieces close the loop:

• Evidence-based completion — when a later email or meeting shows a task is finished (“signed copy attached, thanks”), TimeSentry marks it done, with the evidence recorded and a one-click undo. The confidence bar for acting on your behalf is yours to set, and it starts high.
• Smart merging — the same work item surfacing from an email, a chat, and a meeting becomes one suggested task, not three.

For attorneys and consultants juggling requests across five channels, this is the difference between a task list you maintain and one that maintains itself.

Billing standards were never really a single-company thing. A firm’s activity codes need to reach every employee, contractor, and AI agent doing the work; a client’s outside-counsel guidelines need to reach every firm on the matter. Until now, each company on TimeSentry kept private copies — retyped, drifting, and quietly out of date.

Shared resource catalogs fix that. Group your time-entry guidelines and activity categories into catalogs, then share each catalog exactly where it applies: one matter, one client, your whole company, or an entire relationship class.

• Sharing that follows your working relationships. Share a catalog with “all contractors” once, and every contractor you add later inherits it automatically. End the relationship and access ends with it — nothing to clean up, nothing to remember.
• Their codes, your rates. A category shared with you arrives without the owner’s billing rate. Set your own default rate for it, or hide codes that don’t apply to your work.
• Guidelines with authority built in. When guidelines resolve on an entry, the most specific and most upstream source wins — a client’s rules outrank the firm’s, which outrank personal defaults — and every guideline shows who it came from.
• Revocation without wreckage. Stop sharing and history stays intact: past entries keep their categories, clearly marked as no longer shared, while new time can’t use them.

AI agents participate like everyone else — an agent on your team inherits the same codes and drafting rules as a human timekeeper, from the same catalogs.

The philosophy: your working relationships already say who should see your standards. Sharing should just follow the graph.

Connected inboxes, calendars, chats, and phone lines capture everything — which is the point, and also the problem. Newsletters, promo blasts, internal standups, and personal appointments don’t belong on a timesheet, and until now the only filter between your inbox and your suggested entries was the AI’s judgment.

Integration rules put that judgment in your hands. On any connected email, calendar, chat, or phone source, define conditions — subject contains, sender includes a domain, attendees include a client — and choose what happens when new items match:

• Skip — newsletters and automated notifications never become entries at all
• Mark as spam — captured but kept out of your dashboards and totals
• Assign a project — when you already know where the work belongs, the rule maps it directly with full confidence, no AI guesswork. Your Tuesday standup lands on the right matter every single week.
• Save or submit automatically — entries you’d approve anyway go straight through, combining with project assignment so recurring work bills itself

Rules run before anything is drafted, evaluated top to bottom with the first match winning — the same mental model as your email client’s filters, with multiple conditions per rule and exceptions layered above broad strokes. For attorneys with standing client calls and consultants with recurring engagements, this is the difference between reviewing suggestions and having the routine handled.

Manage rules directly on each integration or from a single view in company settings. And a small unlock along the way: source connections like Gmail, Outlook Calendar, and Zoom Phone now have their own home on the integrations manage page.

The philosophy: the AI drafts your day; rules encode what you already know.

Every practice management system has its own vocabulary. Clio calls them matters. MyCase calls them cases. TimeSentry called them projects — and if you came from one of those systems, every screen felt slightly foreign. That friction compounds: a mapping page that says “Map TimeSentry Projects to Clio Matters” makes you pause to translate, every single time.

Project aliasing lets you choose whether TimeSentry speaks in projects, matters, or cases. One setting in Advanced Settings, and the entire application follows — navigation, table headers, modals, search fields, toast messages, analytics groupings, and integration mapping pages all reflect your choice. When a Clio firm sets the alias to “Matter,” the integration page reads “Map TimeSentry Matters to Clio Matters.” No more mental translation.

The alias propagates everywhere users interact with the concept:

• Navigation and page titles — sidebar links, staffing views, and task groupings all use your term
• Forms and modals — “Add New Matter,” “Matter Name,” search placeholders
• Integration mapping — QuickBooks, Clio, MyCase, Filevine, and Notion mapping headers, import buttons, and sync labels adapt automatically
• Analytics — chart group-by dropdowns, PDF report headings, and summary metrics

The default is “Project” — nothing changes unless you opt in. For firms already on Clio or MyCase, this is one toggle that makes the whole product feel purpose-built for their workflow rather than adapted to it.

Professional services firms don’t just bill time — they generate, review, and ship documents. A pleading, a deliverable, a contract redline, a discovery production. Until today, TimeSentry tracked the time it took to produce those documents but had nothing to say about the documents themselves. That asymmetry never made sense to us.

Documents is now a first-class resource in TimeSentry. You can upload a file, link it to a client, project, or task, organize it with categories (Pleadings, Discovery, Closing) and tags (urgent, draft, ready-to-file), and share it across companies through the same approval workflow that already powers time entries and expenses.

The novel piece is the shared lifecycle. A document moves through saved → submitted → approved → rejected → recalled on a per-company basis, just like time entries. A junior associate uploads a draft and submits it; the partner approves; the client receives a clean copy on their side of the relationship. When a downstream company copies a document into their files, it becomes their owned copy — they control it, they can re-share it onward, and the original owner can’t reach across the boundary to claw it back. That’s intentional: once a document leaves your firm, it has left.

A few things worth naming:

• Your files are yours. Documents are isolated per company — there’s no path, accidental or otherwise, where another firm can see your work product. Cross-company sharing happens only when you explicitly send something through the approval chain.
• Downloads are short-lived and direct. When you click Download, the file streams to your browser through a single-use link that expires in minutes. You get the file fast; nothing stays valid afterward.
• Deletes are recoverable. Hit delete by accident? There’s a recovery window — support can restore a document for a day after you remove it.

Categories and tags are yours to define — you pick the schema that matches how your practice is organized, not a generic taxonomy we imposed. Brand-color badges on the table make a glance enough to find what you need.

For attorneys, consultants, and accountants whose deliverables ARE the work product, this turns TimeSentry into one place to track the time, the document, and the approval that says it’s ready to ship.

TimeSentry Desktop has been Windows-only since launch. That changes today.

macOS support for TimeSentry Desktop is now live, with signed and notarized builds for both Apple Silicon and Intel Macs. The app installs cleanly from a DMG — no Gatekeeper warnings, no right-click workarounds, no security exceptions. For attorneys, consultants, and knowledge workers who live on macOS, this closes the last gap in automated desktop time tracking.

The experience is identical to Windows: TimeSentry runs quietly in the background, detects which applications you’re using, and drafts time entries automatically. Browser tabs, design tools, IDEs, document editors — whatever your billable workflow looks like, the desktop app captures it without manual timers.

A few details worth noting:

• Apple Silicon and Intel builds ship separately. The integrations page detects nothing — you pick your architecture. Apple Silicon (M1/M2/M3/M4) users get a native arm64 build; Intel users get x64. Both are signed with a Developer ID certificate and notarized by Apple.
• Same auto-update pipeline. The release manifest now carries download URLs, sizes, and SHA-256 checksums for all three platforms (Windows x64, macOS arm64, macOS x64). Future auto-update improvements will read from this manifest.
• Download from the integrations page. The desktop download section now shows separate cards for Windows and macOS, with architecture-specific buttons for Mac.

The best time tracking tool is the one that works on the machine you actually use.

The agent question is no longer “do I want one.” Most professionals already have one — Claude Code on a workstation, an OpenAI Assistant their ops team built, a custom in-house bot. The harder question is what those agents are allowed to touch, and how the work they do shows up alongside the work humans do. TimeSentry now answers both.

Two new flows on the Agents page:

• Add existing agent — register an agent that runs anywhere else as a first-class entity in TimeSentry. Issue it a scoped API key, define which colleagues it’s allowed to act on behalf of, and its activity flows into your timesheets and project graph the same as any other contributor. Use this when the runtime lives outside TimeSentry and you just want the audit trail.
• Create new agent — provision a brand-new agent without leaving TimeSentry. Name it, write a one-paragraph instruction, click create. The agent is live, has its own conversational surface, and can hold multiple parallel sessions you can switch between like browser tabs. Built on Anthropic’s managed agents platform, so each conversation runs in a fresh sandbox with file editing, shell, and web access.

Every agent — yours or one you brought — is provisioned with a precise working scope. At setup, you choose the people, companies, and projects the agent is there to support. That scope becomes the agent’s environment: purpose-built access, granted intentionally, with the same audit trail as any other contributor in your org.

The philosophy: a custom agent should be configured for the work in front of it. TimeSentry makes that posture the default rather than the upgrade.

For firms that use UTBMS coding, every new matter needs activity and task code sets assigned before time entries can be properly categorized. When cases flow in automatically from MyCase, Clio, or Filevine, those projects arrived without codes — leaving someone to manually configure each one.

Company-level default code sets fix this. In Settings, under Coding Standards, you can now select a default activity set and a default task set. Every new project — whether created manually or synced from an integration — automatically inherits these defaults unless you override them at the project level.

This is particularly useful for firms with standardized billing practices: set your UTBMS defaults once, and new matters are ready for coded time entry from the moment they appear. No more chasing down unconfigured projects after a batch of cases syncs overnight.

A few details:

• Each default is independent. You can set a default activity set without a default task set, or vice versa. Projects that already specify one set will only inherit the other.
• Project-level overrides still work. Defaults are a fallback, not a mandate. Any code set chosen explicitly on a project takes precedence.
• Works across all integrations. MyCase, Clio, Filevine, and manual creation all flow through the same path. Configure once, applies everywhere.

The goal: new matters should be billable-ready the moment they exist, not after someone remembers to configure them.

When your calendar, your desktop activity, your chat tools, and your email pipeline all feed into the same timesheet, the same hour of work shows up as three or four different entries. Most time tracking tools leave that problem to the user. We think that’s backwards — the system has more context about what’s duplicate than you do, and it should use it.

This release introduces automatic AI-driven deduplication. Every hour, a background pass reviews your recently suggested time entries, identifies duplicates that span across tracking sources — a calendar entry and a desktop window for the same Zoom call, a chat thread and a document edit session for the same client work — and collapses them into a single entry with a written rationale you can inspect. The entries that actually represent distinct sub-activities stay as separate line items. Nothing you’ve already saved is ever touched; the agent only cleans up suggestions that are still awaiting your review.

The merge is context-aware. When two sources report the same meeting at slightly different durations, the agent uses the longest as the best estimate. When a single session was tracked in overlapping chunks, the hours add. When redundant observations drift from each other due to measurement noise, they average. Each choice is explained in plain English in the new AI rationale block — visible when you click the info icon next to the confidence bar or open the merge details.

The same pass can also correct misrouted projects. If a desktop entry was initially mapped to the wrong client because the window title was ambiguous, but surrounding entries on the same timekeeper make the right answer obvious, the agent moves it before merging — so what you see in your inbox is one clean entry on the right matter, not three fragmented ones scattered across three projects.

For firms running on multiple capture modalities at once — desktop agent, calendar ingestion, Chrome tracking, AI agent, chat integrations — this is the difference between “lots of raw signal” and “a reviewable timesheet.” The goal isn’t to track more. It’s to show you less, accurately.

When the Assistant answers “what’s on my timesheet today,” the useful answer is a table. When it answers “show my open tasks,” the useful answer is a list. Both had been arriving as a wall of pipe characters, asterisks, and backticks — the raw markdown, not the rendered thing. The reply was technically correct and visually useless.

The in-app Assistant panel now renders its responses as proper formatted content. Tables render as tables — with scrollable overflow when a row is wider than the panel, rather than clipping or forcing the window to grow unreadably. Bulleted and numbered lists render as lists. Bold and italic render as emphasis. Links are clickable and open in a new tab. Code snippets render in a fixed-width block.

We also enlarged the chat panel — roughly 1.5× its prior size — so that the richer responses have room to breathe. The panel clamps to the viewport, so on a laptop it fills what’s available, and on a widescreen monitor it lands at a readable size rather than stretching corner-to-corner.

The effect is small, but it’s the difference between an Assistant you actually read and an Assistant you squint at. For the professionals who are using the panel to answer timesheet and task questions on the fly — which, per usage data, is most of you — this removes the last reason to leave the panel and go look at the underlying screen instead.

A meeting on the calendar is a draft time entry waiting to be written. A meeting that actually happened — with transcript, participants, and decisions — is a complete one. We shipped the second half.

Desktop meeting recording now captures Zoom, Microsoft Teams, and Google Meet calls directly from the TimeSentry Desktop app. When you join a supported meeting on your desktop, TimeSentry prompts you to record — never silently. Consent is explicit, every time. If you accept, the call is recorded and uploaded to TimeSentry, transcribed automatically, and returned as a draft time entry with a full transcript, an AI-generated meeting summary, and suggested follow-up tasks — ready for you to review, edit, and submit.

For attorneys, consultants, and account managers whose day is mostly live conversation, this closes the gap between “I had a one-hour call” and “here’s a time entry with a client, a matter, a narrative, and action items.” The hour no longer has to be reconstructed from memory.

A few design choices worth naming:

• No silent recording. Every detection prompts for consent. The toggle defaults to off. Meeting capture is something you opt into, per meeting, not a surveillance setting you forget you turned on.
• The SDK runs next to your work, not in the cloud. Unlike bots that dial into a meeting as a visible participant, this captures the audio stream locally and uploads it afterward. Other attendees don’t see a “TimeSentry Bot” in the participant list.
• One pipeline for every meeting source. Whether a meeting was recorded by our Slack huddle bot, our meeting bot joining a calendar link, or now the desktop recorder — the downstream pipeline is identical: transcript → AI summary → draft time entry + meeting notes + suggested tasks. Your notes live in the same place regardless of how the meeting was captured.

Meetings are the single richest source of billable narrative in professional services. They should also be the easiest to track.

When you start a timer from inside Word, PowerPoint, or Excel, the form shouldn’t sit empty while you wait for the backend to catch up. That’s what had been happening — a thirty-second delay between hitting Start and seeing the first drafted time entry. For users who were opening the taskpane mid-session to glance at the draft and keep working, it felt broken.

The add-ins now fire the first heartbeat the instant the timer starts, and the description field shows a “Drafting…” pending state so it’s obvious the system is working rather than stalled. The draft populates the moment the backend responds — typically a second or two, instead of half a minute.

We also added a Company selector inside each taskpane. Consultants and attorneys who run time against multiple entities — a main practice and a side LLC, a firm and a referring-counsel engagement, a parent company and a subsidiary — can now pick which entity a document session bills to, directly from the add-in, without changing their global active company. The selector defaults to your active company, so the experience is unchanged until you need it.

The effect is less friction for the users who need it most: professionals whose billable day crosses multiple companies, and who measure setup time in heartbeats.

When an email becomes a time entry and that time entry is pushed to Clio, the email itself has always stayed behind in Outlook or Gmail. The attorney sees an Activity on the matter, but the underlying message — who it was to, what it said, what was attached — lives in a separate system entirely. Opening Clio to review a matter meant opening a second tab to reconstruct the conversation that drove the work.

This release closes that gap. When you sync an email-sourced time entry to Clio, TimeSentry now also posts the source email as a Communication on the matter, links it back to the Activity, and uploads every file attachment as a Document on the Communication. The subject, body, senders, and receivers are populated from the original message; recipients already synced as Clio contacts are resolved to their matching party records; attachments land within seconds of the sync completing. A reviewer opening the matter in Clio sees the Activity, the email it came from, and every file that traveled with it — without leaving Clio.

The feature is opt-in per firm and lives on the Clio integration page under Automatic Syncing. Once enabled, it applies to every email-sourced time entry across Outlook, Gmail, Microsoft Exchange, and Zoho Mail. Time entries that weren’t created from an email are unaffected; a failure to post the Communication never blocks the underlying Activity sync. The email body is rendered as plain text for Clio’s communication view, and HTML markup is stripped rather than pasted as raw tags.

For firms whose matter files are the source of truth — and whose malpractice posture depends on being able to reconstruct the record of a matter from one place — this turns “the email that became this time entry” from a manual lookup into a built-in part of the file.

Most time tracking tools give you one input: a timer button. We think that’s backwards. Your work happens across screens, documents, conversations, and even handwritten notes — so time capture should meet you wherever the work is.

This week we shipped three new capture modalities:

The desktop agent runs a lightweight heartbeat process that groups application-level activity signals into time entries using configurable legal billing increments (6-min / 0.1hr rounding). No screen recording, no screenshots, no surveillance — just process-level metadata interpreted by AI. For attorneys and consultants who live in desktop applications, this closes the biggest gap in automated time tracking: the hours spent outside email and calendar.

Photo-to-time-entry via MMS — snap a picture of handwritten notes, a whiteboard, or a receipt and text it to TimeSentry. The image is processed through our multimodal vision model, which extracts structured time data (client, matter, duration, narrative) and creates a draft entry. This is the same inference stack that powers our email and calendar mappers, extended to unstructured visual input. For professionals who still take pen-and-paper notes in client meetings, this eliminates the transcription step entirely.

Word plugin document-change tracking — the Office add-in now monitors document mutation events and auto-saves time entries as you draft. Combined with the desktop heartbeat, this gives near-complete coverage of document-heavy workflows — brief drafting, contract review, memo writing — without any manual logging.

The AI agent’s tool-calling layer also gained access to your task and project graph, so conversational time management now resolves against real project structure rather than fuzzy name matching. The result: fewer corrections, faster approvals.

Two changes this week that matter most to firms with IT teams and custom workflows.

The desktop app now authenticates via a standard OAuth 2.0 flow with localhost redirect — no more copying tokens from the browser. This sounds small, but it’s the difference between “works for the founder” and “works for a 200-person firm with SSO policies.” Organizations that gate all software behind identity providers can now deploy the desktop agent without exceptions or workarounds.

API key lifecycle management is available in the settings panel. Generate keys, rotate them on a schedule, and scope them to specific integrations. This is the same auth layer that powers TimeSentry’s own agent integrations, now exposed so your team can build custom automations, connect internal tools, or pipe time data into your own reporting systems. We believe the best time tracking platform is one that doesn’t trap your data — it makes it programmable.

Agent companies get a new session ingest pipeline with relationship validation — the system verifies that an agent session maps to a valid company/user relationship before persisting any time data. This is the kind of invisible guardrail that prevents bad data from entering the system in the first place, rather than cleaning it up after the fact.

Time tracking shouldn’t require opening an app. The people who bill the most hours are the ones with the least time to log them — so we built a way to manage your timesheet through the tools you’re already using.

The TimeSentry AI Agent is a multi-channel conversational interface for time entry management. It ingests natural language over three transports and converts it to structured time data:

• Slack — DM the TimeSentry bot or @mention it in any channel. The agent resolves your identity via the Slack workspace mapping, queries your project graph, and creates or updates entries in real time. Ask “what did I bill to Acme this week?” and get an answer with a chart.
• Email — forward a client conversation or send a free-form note to your TimeSentry address. The agent extracts client, matter, duration, and narrative from the email body and thread context. This turns email — already the primary record of client work — into a zero-effort time capture channel.
• SMS/MMS — text your hours from anywhere. No app install required. Combined with the MMS vision pipeline, you can photograph handwritten notes and have them converted to entries on the spot.

The agent isn’t a chatbot bolted onto the side of a CRUD app. It’s a first-class integration type with tool-calling, chart generation, and access to your full project and client graph. The philosophy: if you can describe the work in a sentence, you shouldn’t have to fill out a form.

Also shipped: time entry merge and unmerge. Combine fragmented entries into a single line item for billing, or split a merged entry back out when you need granular detail. The merge preserves source metadata for audit trails — because simplifying a bill shouldn’t mean losing the receipt.

When you’re generating thousands of time entries per day across dozens of integration sources, even small edge cases compound. This week was a focused reliability sprint — the kind of work that doesn’t make flashy demos but determines whether you trust the system.

• Gmail dedup — eliminated duplicate entries caused by sent/inbox label overlap. Added a pre-commit dedup check to prevent race conditions during concurrent processing. Dedup boundary widened to ±2 days for all-day calendar events. The goal: you should never have to manually delete a duplicate entry.
• Email threading — thread-combining now collects all msg_ids for accurate dedup. Stale thread entries are replaced rather than skipped, and thread-based replacement only runs when use_email_threading is enabled. This matters for firms that bill per-conversation rather than per-email — one thread, one entry, correct every time.
• MS Graph calendar — reminder and to-do event types are now filtered at the sync layer so they never reach the mapper. Your timesheet should reflect work, not notification noise.
• Microsoft 365 token rotation — rotated refresh tokens are now persisted correctly, preventing silent auth failures. This was causing intermittent sync gaps for M365 users — the kind of bug where “it works most of the time” is worse than “it never works.”
• Timezone normalization — daily summary email queries and background hourly runs now use company-local time consistently, closing a UTC gap that appeared on date switchover. Time tracking is, at its core, a timezone problem — and we take that seriously.

Not every user wants a friendly dashboard with rounded corners. Some of our highest-volume users — managing partners reviewing firm-wide timesheets, operations leads auditing hundreds of entries — want density, speed, and zero visual clutter.

Terminal Mode is a Bloomberg-inspired interface theme built for exactly that. Amber text on dark backgrounds, area charts with gradient fills, crimson CTAs, and monospace typography where it counts. This isn’t a CSS skin — it changes chart rendering, color palettes, and layout density across every view. Toggle it on in Advanced Settings and your timesheet looks like a trading floor. Gated behind a company-level preference flag so firms can standardize the experience across their team.

Background task processing — bulk operations (remap, retry, archive) now run asynchronously with a real-time notification system. A notification bell surfaces progress as it happens. The UI applies optimistic updates on dispatch and reconciles when the task completes, so the interface never blocks on server-side processing. When you’re remapping 500 entries to a new project, you shouldn’t have to watch a spinner — you should be able to keep working and get notified when it’s done.

This is part of a broader principle: TimeSentry should feel instant regardless of the volume of data behind it.

Time tracking is the foundation, but the real value is what you build on top of it. This week we shipped two features that extend TimeSentry from a time capture tool into a financial planning surface.

FP&A scenarios — the financial planning module now supports multiple named scenarios (baseline, optimistic, conservative) with independent payment streams. Filter cash flow projections by scenario, drill down into line items with inline editing, and bulk-import data from Excel via a paste modal that parses tab-separated values into the scenario grid. For firm owners and CFOs, this means you can model “what if we lose this client” or “what if we hire two associates” directly against your real billable hour data — not in a disconnected spreadsheet.

Archive and spam filtering — time entries can now be archived individually or in bulk. The archive pipeline applies at the query layer, so archived entries disappear from the default view without being deleted. A spam classifier pre-filters low-signal entries (automated notifications, marketing emails) before they ever reach the AI mapper. The philosophy: your timesheet should only contain entries worth reviewing. Everything else should be handled automatically, with a clear audit trail if you ever need to look back.

Clio integration received no-charge field support directly on the time entry table — toggle no-charge status without leaving TimeSentry — plus a fix for a contact sync query that was degrading onboarding performance for large Clio accounts.

We built TimeSentry’s FP&A module because we saw firms exporting time data to Excel, building financial models manually, and then importing the results back into their practice management system. That’s three tools and a dozen steps for something that should be one surface.

The FP&A grid now implements spreadsheet-level interaction patterns: cell selection, fill-down, and paste-over ranges. Combined with inline editing and statement drill-down, you can build and adjust financial statements without switching tools. The grid handles cell-level focus management and keyboard navigation natively — it should feel like the spreadsheet you’re used to, but connected to live time and billing data.

Bulk retry and remap — when the AI maps entries to the wrong client or project (it happens — especially early in onboarding when the model is still learning your firm’s naming conventions), you can now select multiple entries, reassign the mapping, and reprocess them through the AI pipeline in a single operation. The remap runs asynchronously via the background task system with polling-based progress updates. This turns what used to be a tedious one-by-one correction into a single bulk action — and every correction makes the AI smarter for next time.

Time tracking only matters if it connects to billing. This week we shipped two new integration pipelines that close the gap between “hours worked” and “invoice sent.”

• QuickBooks Online — bidirectional invoice sync with date and project filtering. Client resolution runs through the existing entity-matching layer, so QBO contacts map to your TimeSentry client graph automatically. For firms that bill out of QuickBooks, this eliminates the manual step of recreating time entries as invoice line items.
• Notion — sync clients, projects, and contracts from Notion databases. Field mapping is configurable per-database, with external ID lookup for dedup and a preview panel that renders Notion properties in-context before you commit the sync. If your firm runs project management in Notion, your TimeSentry projects now stay in sync without manual upkeep.

AI explainability — every AI-generated time entry now exposes its reasoning chain. Click any entry to see which signals (email subject, calendar event, sender, project history) drove the mapping decision. A feedback loop lets you confirm or correct mappings, which feeds back into the model’s per-company learning layer.

This is a core design principle: AI should be auditable. If TimeSentry maps an email to the wrong client, you should be able to see why it made that decision — not just fix it and hope it doesn’t happen again. Explainability turns a black box into a system you can trust and train.

You can’t improve what you can’t measure. Most time tracking tools give you a list of entries and a total at the bottom. We think that’s a missed opportunity — your time data contains patterns, trends, and revenue insights that should be surfaced automatically.

New analytics dashboard with stacked area charts, trend lines, and revenue breakdowns computed from your time entry data. The backend resolves query bottlenecks in the revenue calculation path and caches results with automatic invalidation on time entry mutations — so analytics load instantly even on large datasets. See where your time goes, which clients drive the most revenue, and how your effective billing rate trends over time.

• Multi-axis filtering — filter the time entry table by hours, AI confidence score, billing status, and integration source. Filters compose and persist across sessions, so your preferred view is always waiting for you.
• Summary metrics bar — total hours, billable hours, and projected revenue rendered at the top of the timesheet with calendar week breakdowns. The numbers that matter, always visible.
• Calendar week view — a new visualization mode for seeing time distribution across the work week. Spot gaps, identify overloaded days, and understand your utilization at a glance.

The analytics engine is designed to scale with your firm. Whether you’re a solo practitioner reviewing a week of entries or a managing partner analyzing a quarter across 50 timekeepers, the experience should be the same: fast, clear, and actionable.

Time entries are the raw material. But professional services firms need to connect those hours to contracts, rates, staffing plans, and client relationships. This week we started building that connective tissue.

• Contracts & staffing — first-class data models with rate hierarchies, staffing assignments, and summary views. Contracts feed into the FP&A module and the billing rate resolver, so rate lookups now walk the chain: entry → category → contract → company default. This means the right rate is applied automatically based on who did the work, what type of work it was, and which contract governs it — no manual rate selection.
• Multi-Gmail support — connect multiple Gmail accounts to a single TimeSentry user. Each inbox is processed independently through the email pipeline with per-account dedup. For professionals who maintain separate inboxes for different clients or roles, all of that activity now flows into one unified timesheet.
• Chrome extension — capture time from any browser tab with AI project mapping. The extension calls the same AI classification endpoint as the email and calendar pipelines, so mapping is consistent across all input sources. Research in the browser, correspondence in email, meetings on the calendar — it all maps to the same project graph.

Onboarding was rebuilt with skippable steps, real-time Clio sync progress, and a folder-mapping wizard with auto-selection. Getting started with TimeSentry should take minutes, not hours — and it shouldn’t require reading a manual.

We started 2026 by rebuilding the infrastructure that lets us ship with confidence. The goal: deploy multiple times per week without breaking anything, and know immediately when something goes wrong.

• CI/CD pipeline — containerized builds with templated deploys to Azure Kubernetes. Stage and production environments are now fully isolated with unique revision suffixes per workflow run. Every pull request gets a staging deploy, every merge to main goes to production automatically.
• Observability — session replay with privacy-first masking, active company context on every error report, and user identity propagation across the frontend and API. When a customer reports an issue, we can see exactly what happened — without recording sensitive data.
• Automated release management — semantic versioning and changelog generation from conventional commits. 17 releases shipped in Q1 with zero manual tagging. This is why you see updates on this page nearly every week.

On the product side, we shipped cross-dimensional analytics matrix endpoints for reporting across client, project, and time dimensions simultaneously — laying the groundwork for the analytics dashboard that shipped in February.

We believe the speed at which a product improves is the most important feature. Infrastructure isn’t glamorous, but it’s what makes everything else on this page possible.