Takt

Find where your hours changed. Takt lines up schedules, timecards, pay stubs, and messages, shows

Comment

Inspiration

A worker can have four records describing the same shift differently: a schedule screenshot, an employer timecard, a pay stub, and a message from a manager asking them to come in early.

None of those records alone necessarily proves what happened.

The difficult part is reconstructing the day, showing exactly where the records disagree, and turning that evidence into something the worker can actually inspect and use.

California's wage-claim process already asks workers to organize supporting records such as time records and pay stubs. Takt was built around that job.

Instead of building another AI lawyer or a model that declares someone was underpaid, we asked a narrower question:

Can software reconcile the records a worker already has, keep every important value tied to its source, require the worker to confirm consequential facts, and produce a packet that can be independently checked?

That became Takt.

What it does

Takt reconstructs worked time from a worker's own records.

A worker can add:

  • schedules
  • employer time records
  • pay stubs
  • manager messages

Takt extracts candidate facts and shows exactly where each value came from in the original document.

The worker then confirms, corrects, or rejects those facts.

Only after confirmation does Takt line the records up day by day.

For example, in our canonical synthetic case:

  • the schedule and manager message support a 7:40 AM start
  • the employer time record starts at 8:00 AM
  • the worker confirms the earlier start
  • Takt identifies a 20-minute discrepancy

A schedule alone never counts as worked time.

The reconciliation engine then performs deterministic time and pay calculations under Takt's supported California scope.

Takt can generate:

  • the official California DLSE Form 1
  • the official Form 55 workbook where applicable
  • an evidence index
  • a calculation file
  • a manifest containing source and output fingerprints

The packet can then be independently re-read, re-hashed, and recomputed.

If evidence is missing, records conflict in a way Takt cannot resolve, or the employment situation falls outside the rules we implemented, Takt stops instead of inventing an amount.

How we built it

Takt is a Next.js and TypeScript web application.

The product is deliberately split between AI-assisted extraction and deterministic decision logic.

For digital PDFs, Takt reads the document's own text and coordinates locally in the browser.

For supported synthetic image examples, Gemini proposes structured candidate facts together with source regions and quoted text.

AI does not decide whether a discrepancy exists, calculate money, fill the government forms, or verify the final packet.

Every consequential value passes through typed Zod contracts and worker review.

The reconciliation and calculation layers are plain deterministic TypeScript. Time is represented using integer minutes and money uses exact arithmetic rather than model-generated calculations.

For official artifacts:

  • DLSE Form 1 is populated through its PDF form structure and read back with a separate PDF library
  • Form 55 is the official legacy .xls workbook, so Takt patches the workbook while preserving its formatting
  • source files and outputs are SHA-256 fingerprinted

Takt's verifier does not simply trust the state that generated the packet. It re-reads the manifest, checks file fingerprints, replays the reconciliation, recomputes the arithmetic, and rejects modified packets.

The current release has 110 passing unit and integration tests, production browser tests on desktop and mobile, clean lint and type checking, and dedicated control, ambiguous, unsupported, and tamper cases.

Challenges we ran into

Government forms are not clean developer APIs

Form 1 contains old internal field names that no longer match some of the visible questions, so we could not safely map fields by name alone.

Form 55 was another surprise: the official artifact is a legacy BIFF8 .xls workbook rather than a modern spreadsheet or PDF.

We built read-back tests for both instead of assuming that successfully writing a file meant the output was correct.

Keeping AI inside the right boundary

A language model can easily turn uncertain evidence into a confident legal-sounding answer.

Takt does not allow that.

AI proposes facts. The worker confirms consequential facts. Deterministic code reconciles the records and performs the calculations.

We also built refusal paths for incomplete evidence and unsupported cases.

Privacy on the public hackathon deployment

Worker records can contain sensitive personal information.

The public Takt deployment therefore does not send arbitrary user images to Google's unpaid Gemini API.

Only committed synthetic sample images are allowed through the server's AI extraction path. Unknown images are rejected before a model call, and workers can enter what their records show manually.

Digital PDFs with readable text are processed locally in the browser.

Proving failure, not only success

We wanted the verifier to demonstrate more than a successful happy path.

We created mutated packets and changed values, files, and form data.

The verifier rejected 10/10 tampered packets.

Accomplishments that we're proud of

The part we are most proud of is that Takt's result stays inspectable from beginning to end.

In the canonical synthetic case, a judge can follow the chain from:

7:40 AM in the source evidence → worker confirmation → 8:00 AM employer record → 20-minute discrepancy → deterministic calculation → government forms → verified packet

We also built first-class negative cases:

  • a matching control case produces no false discrepancy
  • an ambiguous case refuses to calculate
  • an unsupported piece-rate case stops with a reason
  • tampered packets fail verification

Across the committed synthetic campaign, expected and observed outcomes matched for all four cases, with no false discrepancy on the matching control.

We are also proud that Takt uses the actual current California artifacts rather than recreating generic lookalike forms.

What we learned

The biggest lesson was that legal-tech reliability is less about producing more text and more about controlling where facts come from and who is allowed to make each decision.

A source location is more useful than an unexplained confidence score.

A worker correction is more important than a polished AI summary.

A deterministic calculation that can be reproduced is more useful than asking a model to estimate what someone is owed.

And successful file generation is not verification. Reading the output back through an independent path found problems that a write-only implementation would have missed.

We also attempted a comparison against a general-purpose multimodal AI workflow. The provider returned repeated high-demand errors, so the benchmark did not complete. We withdrew that comparison rather than treating provider failure as a bad answer or publishing a result we could not support.

What's next for Takt

The current version intentionally supports a narrow, explicit scope: standard California hourly, non-exempt work under the rules we implemented.

Next we would validate the workflow with worker-rights organizations and real users under an appropriate privacy setup, then expand the rule engine only where each new case type can preserve the same guarantees:

  • source-linked evidence
  • explicit worker confirmation
  • deterministic calculations
  • honest refusal outside supported rules
  • independently verifiable outputs

Takt is not legal advice and does not file a claim for the worker.

The goal is simpler: turn fragmented work records into an evidence trail the worker can inspect, correct, understand, and carry forward.

Built With

Share this project:

Updates

Submission history