ReplikitA Continuis Labs Experiment
Join the waitlist
Replikit · A research workspace

Read once. Scaffold automatically. Query your whole corpus.

Replikit is the workspace where every paper you save becomes a typed Python scaffold, every notebook lives next to its source paper at a stable URL, and the whole project answers questions in your team's voice. Reading becomes a codebase your collaborators can build on — not a folder of PDFs nobody opens twice.

Join the waitlistSee the demo
The Problem

Reading is solo. Building is solo. The notes get lost. The next collaborator starts from zero.

Every paper you've tried to reproduce had the same shape: a tidy methods section, a clear equation, a dataset name, and somewhere between three weeks and never of guessing at the hyperparameters, the library versions, the preprocessing details the authors didn't think to write down.

The deeper problem isn't any single paper — it's that the work disappears between papers. The notebook you wrote last quarter is on a laptop you've since replaced. The Slack thread where you compared baselines is unsearchable. The next collaborator joins your project and you re-explain six months of reading from memory.

Replikit is the place that workflow lives. Papers, notebooks, methods docs, dataset hooks, and discussions in one project. Hosted, queryable, versioned. The corpus you build today is the substrate the next person on your team starts from.

36%
of psychology studies replicated in the Reproducibility Project

Nosek et al., 2015

70%
of ML researchers report failing to reproduce a paper at least once

Nature, 2016 survey

3wk
average time spent reimplementing a single paper's methods

r/MachineLearning consensus

The Solution

Six layers. Paper in. Scaffold, docs, and a queryable project — out.

Replikit is document-aware and project-shaped. Every paper you save lands in a workspace alongside the notebook it generates, the docs that explain it, and the corpus it joins. The next collaborator inherits the whole project, not the conversation that built it.

  1. 01

    Drop in an arXiv URL or a PDF

    Paste an arXiv link, an OpenReview link, or upload the PDF directly. Replikit parses structure (methods, datasets, equations, hyperparameters) instead of treating it as raw text.

    • arXiv
    • OpenReview
    • PDF upload
  2. 02

    Extract — sections, equations, datasets, hyperparameters

    A document-aware parser identifies the algorithm boundaries, pulls out LaTeX equations, identifies named datasets and benchmarks, and surfaces hyperparameters from the experimental setup.

    • LaTeX-aware
    • Dataset detection
    • Hyperparameter extraction
  3. 03

    Match against the knowledge graph

    Replikit looks up the paper, its authors' prior work, known implementations of cited methods, and the canonical libraries the field uses. You inherit context the chatbot doesn't have.

    • Citation graph
    • Known impls
    • Library inference
  4. 04

    Generate — a notebook scaffold, not a guess

    Function stubs with full type signatures. Equations rendered inline. Suggested libraries imported. Hyperparameters wired up to argparse. Cells annotated with the section of the paper they implement.

    • Jupyter
    • Type signatures
    • Cited cells
  5. 05

    Companion docs — methods.md, dataset.md, expected-results.md

    Alongside the notebook, Replikit ships markdown that explains the methods in your own working notation, lists the datasets with auto-fetch commands, and records what numbers the paper reports — so you know when you're done.

    • methods.md
    • dataset.md
    • expected-results.md
  6. 06

    Export — Jupyter, Colab, or Hugging Face Spaces

    Download the notebook, push to a Colab tab, or scaffold a Hugging Face Space. Citation metadata exports as BibTeX. Your reading list and your code stay in sync.

    • Colab
    • HF Spaces
    • BibTeX
Live preview

A project. Three papers. One queryable corpus.

The demo below is a real project view: three papers, a generated notebook for each, and a Corpus Q&A tab that asks questions of the whole project at once. Switch papers to see their per-paper scaffolds; switch to Corpus Q&A to see what the workspace gives you that a chat session can't.

Project

Transformer Replication Sprint

3 papers · 3 notebooks · hosted at replikit.dev
Papers
vaswani-2017.pdf
3.2.1   Scaled Dot-Product Attention

We call our particular attention "Scaled Dot-Product Attention" (Figure 2). The
input consists of queries and keys of dimension d_k, and values of dimension d_v.
We compute the dot products of the query with all keys, divide each by sqrt(d_k),
and apply a softmax function to obtain the weights on the values.

In practice, we compute the attention function on a set of queries simultaneously,
packed together into a matrix Q. The keys and values are also packed together
into matrices K and V. We compute the matrix of outputs as:

    Attention(Q, K, V) = softmax(Q · K^T / sqrt(d_k)) · V                    (1)
Extracted structure
  • Algorithm

    scaled_dot_product_attention

  • Inputs

    Q (d_k), K (d_k), V (d_v), optional mask

  • Equation

    Attention(Q,K,V) = softmax(QKᵀ / √d_k) · V

  • Hyperparameters

    d_k=64, d_v=64, h=8 heads

  • Datasets

    WMT 2014 EN-DE (4.5M), WMT 2014 EN-FR (36M)

  • Library

    PyTorch ≥ 1.12 / JAX 0.4+

  • Known impls

    fairseq, x-transformers, tensor2tensor

  • In your corpus

    Cited by he-2015 (no), ba-2016 (no)

Output
import math
import torch
import torch.nn as nn
import torch.nn.functional as F


class ScaledDotProductAttention(nn.Module):
    """
    Scaled Dot-Product Attention (Vaswani et al., 2017, §3.2.1).
    Equation (1): Attention(Q, K, V) = softmax(Q K^T / sqrt(d_k)) V
    """

    def __init__(self, d_k: int, dropout: float = 0.0):
        super().__init__()
        self.scale = 1.0 / math.sqrt(d_k)
        self.dropout = nn.Dropout(dropout)

    def forward(
        self,
        q: torch.Tensor,        # (B, h, T_q, d_k)
        k: torch.Tensor,        # (B, h, T_k, d_k)
        v: torch.Tensor,        # (B, h, T_k, d_v)
        mask: torch.Tensor | None = None,
    ) -> torch.Tensor:          # (B, h, T_q, d_v)
        scores = (q @ k.transpose(-2, -1)) * self.scale
        if mask is not None:
            scores = scores.masked_fill(mask == 0, float("-inf"))
        weights = self.dropout(F.softmax(scores, dim=-1))
        return weights @ v

Project view. Switch papers to see the scaffold for each one. Switch to Corpus Q&A to query the whole project.

Your research workspace

A workspace, not a one-shot tool.

Each capability below is something the project itself gives you — accumulated across every paper you add, available to everyone you share the project with.

Pricing

Pricing by usage, not by team size.

Pricing locks in the day the product ships. Reserve the early-access tier now to lock in 50% off for life — see below.

Early-access reservation

Reserve a Researcher plan at $14/mo — 50% off, for life.

First 500 reservations only. No charge until launch — refunded if Replikit doesn't ship within 6 months.

Reserve early access
What's Next

What ships after v1.

Driven by what waitlist researchers tell me their actual reproduction blockers are.

Join the waitlist

The earlier you join, the more you shape v1.

I'm Tom — a data engineer who has spent more weekends than I'd like reimplementing other people's papers from scratch. If you've ever filed a reproducibility issue in your own head and not in a GitHub issue, your input shapes Replikit.

Built for ML researchers, PhD students, R&D engineers. Reply to the confirmation email and tell me about your specific situation — that's what shapes v1.

No spam. One confirmation, then only when there's news.

FAQ

Honest answers.