$SENTIK CA: TBA
Open app
$SENTIK CA: TBA

Resume Interrupted GPU Transcriptions.

Retry only the failed audio segments. Sentik splits a long recording into hashed segments, keeps every finished segment, sends only the failed ones back to the GPU, and stitches the transcript with timestamps.

Working prototype. No speech model ships with it: the demo engine is simulated and prints placeholder text. Audio stays in your browser. The Elysium contract is tested, not deployed. No token is needed.

board-meeting.wav · 12:00 · 24 segmentsSample data
13
Done
1
Failed
16
Engine calls
1
Retries
01234567891011121314151617181920212223

segment 13 failed on attempt 1: simulated GPU loss

segment 5 done on attempt 2

[simulated] placeholder words stand in for real speech…

Built on open pieces you can check

  • Web Audiodecode in the browser
  • SHA-256one hash per segment
  • Merkle rootone value per job
  • Elysiumchain 99901, gas HYPE
  • IndexedDBprogress survives a reload
Why Sentik Exists

Long Recordings Fail Late

A two-hour meeting is one long job on one GPU. When the GPU is lost at minute 71, most pipelines keep nothing and start again from zero. Notes agents wait, and the same minutes are paid for twice.

Preempted GPU

A spot or shared GPU is taken back mid-job. Everything that was in memory is gone.

Driver or kernel crash

One bad frame or an out-of-memory error ends the whole process, not one sentence.

Timeouts on long files

A two-hour recording outlives the request or worker timeout it was sent with.

Lost progress

Most pipelines keep the transcript in memory until the end, so a failure at minute 71 keeps nothing.

Paying twice

A restart from zero bills every minute again, including the ones that had already worked.

No proof of what ran

After retries, nobody can show which audio produced which lines, or that none were skipped.

A Worked Example
A 90-minute recording loses its GPU at minute 71. Without segments, all 71 minutes go back to the GPU. With 30-second segments, Sentik keeps the 142 that finished and re-sends only the one or two that were in flight, then stitches the rest in order.
90:00Arithmetic, not a customer90 min · 30 s segments · failure at 71:00
What Resume Saves

Audio sent again after that failure, without segments

79%

71 of 90 minutes go back to the GPU, because nothing before the failure was kept.

Audio sent again with Segment Resume

1.1%

At most two 30-second segments (60 s of 90 min) were in flight. Arithmetic for this example, not a measurement of any engine.

How It Works

01

Split

The recording is cut near every 30 s, moved to the quietest 20 ms nearby so a cut rarely lands inside a word.

02

Hash

Each segment's 16-bit PCM bytes get a sha256. The list of segments and their offsets becomes a manifest with one Merkle root.

example · seg 3 · 00:01:30.020 → 00:02:00.410
sha256 0x9c41…e07a
root 0x5d2b…41f8
03

Run per segment

Segments go to your engine one by one (two at a time by default). Each result is saved the moment it is ready.

04

Retry only what failed

After a crash or a failed attempt, the next run skips every finished segment and sends only the failed or unfinished ones.

012345678
05

Stitch

When every segment is done, the lines are joined in order with their own timestamps. A hole blocks stitching instead of hiding.

Who Sentik Is For

Sentik is built for people who:

  • Builders of meeting-notes and minutes agents
  • Teams transcribing long interviews and hearings
  • Anyone running speech models on spare or spot GPUs
  • Pipelines that must show what audio produced what text

Split, Keep,
Resume

The same job, the same failure: what the second run has to do.

Run 1: the GPU is lost while segment 13 is in flight

01234567891011121314151617

13 segments of work finished before the failure.

Run 2: resume

01234567891011121314151617

The 13 finished segments are kept. Only segment 13 and the 4 never started run. 5 engine calls to recover.

keptfailedruns in run 2
Now The Question Is…

Which segments failed last night, and can you prove the rest?

Frequently asked questions

What does Sentik do today?

It splits a recording into hashed segments, runs them through an engine, saves each result as it finishes, retries only failed segments, and stitches the transcript with timestamps. It all runs in your browser on this site, and as a Node runner you start on your own machine.

Does it transcribe speech?

Not by itself. Sentik ships no speech model. The demo uses a simulated engine that prints placeholder words derived from each segment's hash, so you can watch resume and retry work. A developer plugs a real local engine into the documented interface.

Is my audio uploaded?

No. On this site the file is decoded and hashed in your browser and never sent anywhere. The runner in the repository reads files from your own disk. Only hashes can go on chain, and only if you choose to commit them.

What happens if I close the tab mid-run?

Finished segments are stored in this browser (IndexedDB) after each one. When you come back and load the same file, the job resumes: finished segments are kept and only the rest run.

Why is there a contract on Elysium?

So a job's segment list and its results can be checked by anyone later. The SentikSegmentManifest contract stores the manifest root, one receipt hash per segment, which segments are still missing, and a digest of all results when the job is finalized. It stores no audio, no text and no funds. It is written and tested but not deployed yet.

Do I need $SENTIK?

No. Nothing on this site needs the token. Any utility (for example credits for a hosted GPU pool) is a concept that would only make sense once such a service exists.

What are the risks?

This is a prototype. The simulated engine output is not a transcription. Receipts on chain prove which hashes were posted, not that the text is correct. Gas is paid in HYPE for every on-chain write. Token prices can go to zero.

See Sentik
In Action Today

Every feature with its honest status. Prototype runs today; Concept is not built.

  • Segment planner · Splits a recording near every 30 s at the quietest 20 ms, with a sha256 per segment.Prototype
  • Resumable runner · Keeps each segment's result as it finishes; a reload or crash loses only the segments in flight.Prototype
  • Retry failed only · A second run touches only segments whose last attempt failed.Prototype
  • Stitched transcript · Lines in order with their own timestamps; TXT, SRT, VTT and JSON.Prototype
  • On-chain manifest · SentikSegmentManifest on Elysium: commit, receipts, missing list, finalize. Written and tested, not deployed yet.Prototype
  • Speech engine · No model ships with Sentik. The demo uses a simulated engine; you plug in your own local engine.Concept
  • Hosted GPU pool · Workers run by others that pick up your segments. Not built.Concept
  • $SENTIK utility · Only once a paid service exists. Nothing here needs the token.Concept
Live from Elysium
Elysium block Livereading…
Block agereading…
Gas pricereading…
Commit a manifest nowreading…
Manifest contractNot deployed yet
Gas tokenHYPE
$SENTIK contract addressThe $SENTIK address on Elysium is published at launch

$SENTIK is not needed for anything on this site. Launchpad TBA; the address appears here at launch. Gas on Elysium is paid in HYPE.

Open Segment Resume