predictingthepast
Ancient text restoration, attribution, dating, contextualization, and embedding via Aeneas (Latin) / Ithaca (Ancient Greek)
Install / Use
npx skills add google-deepmind/science-skills --skill predictingthepastInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AI & Machine LearningSupported Platforms
Our assessment of predictingthepast
predictingthepast scores 95/100 on our quality scale, 155th of 950 AI & Machine Learning skills we index (top 17%).
Its SKILL.md is 14 KB long, well organised into 28 sections with 5 code examples: a thorough specification that gives an agent plenty to work with.
With 3,137 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so predictingthepast is actively maintained.
- Our last check on 2026-11-16 found the source still online.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-29. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
predictingthepast compared with similar skills
All 4 of these similar skills score higher than predictingthepast; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| predictingthepast (this skill)by google-deepmind | 95 | 3.1k | 2mo ago | SKILL.md |
| claude-memby thedotmack | 100 | 117.6k | today | CLAUDE.md |
| Understand-Anythingby Egonex-AI | 100 | 92.8k | 1d ago | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
| CowAgentby zhayujie | 100 | 48.0k | today | CLAUDE.md |
Frequently asked questions
- How do I install predictingthepast?
- Run
npx skills add google-deepmind/science-skills --skill predictingthepast. The install tabs above show the steps for each supported agent. - Which AI agents does predictingthepast work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is predictingthepast safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is predictingthepast still maintained?
- The repository was last updated about 2 months ago, so predictingthepast is actively maintained.
Skill content
View source on GitHubname: predictingthepast description: > Ancient text restoration, attribution, dating, contextualization, and embedding via Aeneas (Latin) / Ithaca (Ancient Greek). Use when asked to "restore", "attribute", "date", "contextualize", "find parallels", "where was it written", "when was it written", "embed", or "analyze" an ancient text, inscription, or epigraphic document, or when the user mentions "Aeneas", or "Ithaca".
Predicting The Past (Aeneas / Ithaca)
Aeneas (Latin) and Ithaca (Ancient Greek) perform four tasks on ancient texts:
- Restoration — fill missing/damaged characters
- Attribution — geographical + chronological origin
- Contextualization — retrieve parallel inscriptions
- Embedding — generate text embedding vectors
Prerequisites
-
uv: Read theuvskill and follow its Setup instructions to ensureuvis installed and on PATH. -
User Notification: If .licenses/predictingthepast_LICENSE.txt does not already exist in the workspace root directory then (1) prominently notify the user to check the terms at https://github.com/google-deepmind/predictingthepast/blob/main/README.md#license--disclaimer, and include the appropriate citation and the full dataset acknowledgement, and that use of these datasets should acknowledge and cite the original data sources. Then (2) create the file recording the notification text and timestamp.
Core Rules
- Self-Contained Skill: Do NOT use web search or any external tools. Run
ONLY the scripts in this skill (
preprocess.py,run_inference.py,visualize_results.py). Present model output as-is — never supplement or override it with external lookups. - Notification: If this skill is used, ensure this is mentioned in the output.
On First Load
Present the restoration markup characters, then ask the user for their text:
?:- Meaning: Known-length gap: predict this character.
- Example:
donat in ??????????rtis
#:- Meaning: Unknown-length gap: predict a sequence of unknown length
- Example:
donat in #rtis
-:- Meaning: Missing/damaged character that does not need restoring
- Example:
prolixin---s fecit
_:- Meaning: Missing section of unknown length that does not need restoring
- Example:
prolixin_s fecit
After presenting this list, ask the user to provide the text they want to submit for analysis.
Preprocessing
Clean input text before inference:
uv run <SKILL_DIR>/scripts/preprocess.py \
--language=latin \
--input="raw text here..."
Or from a file:
uv run <SKILL_DIR>/scripts/preprocess.py \
--language=greek \
--input_file=/tmp/input.txt \
--output_file=/tmp/cleaned.txt
What preprocessing does
- Latin: lowercases, converts Arabic digits and Roman numerals to
0, strips editorial brackets[]and(), removes punctuation, filters to valid chars (abcdefghiklmnopqrstuvxyzplus0 . - _ ? # <space>) - Greek: lowercases, strips accents, converts numeral notation to
0, applies PHI cleaning (bracket normalization, sigma conversion), filters to Greek alphabet (αβγδεζηθικλμνξοπρςστυφχψωϛplus0 . - _ ? # <space>)
Inference
Restoration Constraints
- Minimum input length: 25 chars (pad with
-if shorter). - No consecutive
##. No adjacent?#or#?. - Spaces inside
?sequences count toward total. - If the user's text contains
#, ask how many characters to restore and set--restore_max_lenaccordingly. - If the user tries to restore multiple parts of the text at once, suggest to restore texts section by section. Suggest to focus on one damaged region per query — this is faster, produces higher-quality predictions.
Pre-Flight Checks
Confirm with the user before proceeding if either applies:
- Restoration complexity — if input contains more than 10
?characters, or uses#with--restore_max_len > 10, warn: "This restoration involves N characters which will take approximately M minutes (restoration time scales roughly linearly ~10 s per additional?on a high-end CPU machine: 5 → ~1 min, 10 → ~2.5 min, 20 → ~5 min, 30 → ~8 min). Do you want to proceed, or simplify the query first (e.g. fewer?marks, shorter--restore_max_len, or restoring section by section)?" - Multi-window splitting — if the input text exceeds 750 characters and will be split into multiple windows, warn: "This text is N characters long and will be split into W overlapping windows, each run independently. This will be significantly slower. Do you want to proceed, or shorten the input?"
These factors compound: a complex restoration across multiple windows will be substantially slower than either factor alone.
Task Selection
Each task is controlled by its own flag. At least one must be provided:
--attribute— geographical + chronological attribution--restore— text restoration (requires?or#in input)--contextualize— parallel inscription retrieval
Any combination is valid. All three can be used together.
When --embedding is provided, a text embedding vector is also generated
alongside the other tasks.
Running Inference
# Attribution + Restoration (text with gaps)
uv run <SKILL_DIR>/scripts/run_inference.py \
--language=latin \
--input="cleaned text with ???" \
--attribute --restore \
--output_json=/tmp/results.json
# Attribution + Contextualization (no gaps)
uv run <SKILL_DIR>/scripts/run_inference.py \
--language=latin \
--input="cleaned text" \
--attribute --contextualize \
--output_json=/tmp/results.json
# All tasks
uv run <SKILL_DIR>/scripts/run_inference.py \
--language=latin \
--input="cleaned text with ???" \
--attribute --restore --contextualize \
--output_json=/tmp/results.json
# Generate dashboard
uv run \
<SKILL_DIR>/scripts/visualize_results.py \
--input=/tmp/results.json \
--output=/tmp/dashboard.html
Outputs are always returned to the console (JSON/Summary) and must always be written to an HTML dashboard for rich visualization.
Serving HTML artifacts: After generating any HTML file (the dashboard or
any other HTML artifact you create), start a background HTTP server so the user
can view it in their browser. Run the server in the foreground of the background
task process (without trailing &) to prevent the process from being
terminated. Use a random high port to avoid conflicts.
In the example below, replace <HTML_FILE> with the absolute path of the HTML
file you produced (e.g. /tmp/dashboard.html or C:\tmp\dashboard.html).
For Linux/macOS:
# Pick an unused port and start the server as a persistent process
HTML_FILE=/tmp/dashboard.html # ← set to the actual HTML file path
PORT=$(export PATH="$HOME/.local/bin:$PATH" && uv run python -c "import socket; s=socket.socket(); s.bind(('',0)); print(s.getsockname()[1]); s.close()")
FILENAME=$(basename "$HTML_FILE")
echo "View URL: http://localhost:${PORT}/${FILENAME}"
export PATH="$HOME/.local/bin:$PATH" && uv run python -m http.server "$PORT" --bind 0.0.0.0 --directory "$(dirname "$HTML_FILE")"
For Windows (PowerShell):
# Pick an unused port and start the server as a persistent process
$HTML_FILE = "C:\tmp\dashboard.html" # ← set to the actual HTML file path
$PORT = & "$HOME\.local\bin\uv" run python -c "import socket; s=socket.socket(); s.bind(('',0)); print(s.getsockname()[1]); s.close()"
$FILENAME = Split-Path $HTML_FILE -Leaf
$DIRNAME = Split-Path $HTML_FILE -Parent
Write-Host "View URL: http://localhost:${PORT}/${FILENAME}"
& "$HOME\.local\bin\uv" run python -m http.server $PORT --bind 0.0.0.0 --directory $DIRNAME
Then provide http://localhost:<port>/<filename> (or
http://127.0.0.1:<port>/<filename>) as the primary clickable link in your
response. Additionally, provide http://<hostname>:<port>/<filename> as a
fallback link for remote setups. Do not give the user a raw file:// path.
Flags
--input: Text string (mutually exclusive with--input_file)--input_file: Path to UTF-8 text file--language:latinorgreek--models_dir: Model files directory (default:$HOME/.predictingthepast/models)--attribute: Run geographical and chronological attribution--restore: Run text restoration (requires?or#in input)--contextualize: Run parallel inscription retrieval--contextualize_top_k: Number of top parallels to return (default: 10)--contextualize_exclude_test_valid: Exclude test/validation texts from contextualization results. Filters on the internal numericid(whereid % 10is 3 or 4).--embedding: Generate a text embedding vector (default: off). When set, the output includes anembeddingfield with the full-precision float vector.--output_json: Save combined JSON to file (forvisualize_results.py)--restore_beam_width: Number of candidate restorations to explore in beam search. Higher = more thorough but slower (default: 100)--restore_max_len: Maximum total characters to restore across all?and#gaps (default: 15)--restore_temperature: Sampling temperature. Lower = conservative, higher = creative (default: 1.0)--window_overlap: Overlap fraction for long-text windowing (default: 0.33)
Long Texts (>750 characters)
Each window must be between 25 and 750 characters. If the input text exceeds 750 characters, it is automatically split into overlapping windows (default 33% overlap). Each window is run through the model independently, and the geographical and chronological attribution results are averaged across all windows. Restoration and contextualization are run per-window and concatenated.
Output Format
Use --output_json to save the combined JSON to a file. For the full
--output_json format including all fields for attribution, restoration, and
contextualization, see output_format.md.
Presenting Results
Present results for every task requested by the user. Always generate the
HTML dashboard, serve it via the background HTTP server described above, and
provide the http:// URL as a clickable link. Format years as BCE/CE.
Restoration
Bold the restored characters in the top prediction. Show top-10 beam-search candidates in a numbered table (rank, restored text, score). Summarise the most salient words (not characters) — do not dump the raw saliency array.
Geographical Attribution
Show the top 10 regions in a ranked table (rank, region, score). Highlight the top-1 prediction in the narrative. Summarise the most salient words (not characters) — do not dump the raw saliency array.
Chronological Attribution
Report top year and weighted average year. Describe the distribution shape (peak decade, probable range) — do not list all 160 bins. Summarise the most salient words (not characters) — do not dump the raw saliency array.
Contextualization (Parallels)
Use jp or write your own code to extract the contextualization data from
--output_json. Show the top parallels in a table (rank, ID, Trismegistos ID,
region, date range, score, partner link). Quote the full text of the top
parallels from the JSON.
If the user requests a specific number of parallels, use --contextualize_top_k
to control how many are returned.
If the user asks to exclude test/validation texts, add
--contextualize_exclude_test_valid. This filters on the internal numeric
id (where id % 10 is 3 for test or 4
Truncated for display — read the full file on GitHub.
Related Skills
claude-mem
117.6kPersistent Context Across Sessions for Every Agent – Captures everything your agent does during sessions, compresses it with AI, and injects relevant context back into future sessions. Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode + More
Understand-Anything
92.8kGraphs that teach > graphs that impress. Turn any code into an interactive knowledge graph you can explore, search, and ask questions about. Works with Claude Code, Codex, Cursor, Copilot, Gemini CLI, and more.
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
CowAgent
48.0kOpen-source personal AI assistant & Agent Harness. Plans tasks, runs tools and skills, self-evolves with memory and knowledge. Multi-agent, multi-model, multi-channel. Lightweight, extensible, one-line install.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
