Three Cutting‑Edge Open‑Source Projects Redefining AI Infrastructure

LingBot-Map: Real‑time 3D scene reconstruction for robots

GitHub: https://github.com/Robbyant/lingbot-map

Problem

Traditional 3D reconstruction processes all images offline after collection, which is too slow for safety‑critical scenarios such as autonomous driving.

Solution

LingBot-Map performs feed‑forward real‑time 3D reconstruction at about 20 FPS on a consumer‑grade GPU, eliminating iterative optimization.

Core technology

Geometric Context Transformer that unifies camera pose, geometric cues and drift correction in a streaming framework.

Paged KV‑Cache attention that applies operating‑system paging ideas to keep memory stable for sequences longer than 10,000 frames.

Sky masking using an ONNX sky‑segmentation model to filter sky points and improve visual quality.

Performance

At 518×378 resolution the system achieves roughly 20 FPS, which the repository documentation states is significantly better than existing streaming or iterative methods.

How to use

# Install environment
conda create -n lingbot-map python=3.10 -y
conda activate lingbot-map
pip install -e .
# Optional FlashInfer acceleration
pip install flashinfer-python -i https://flashinfer.ai/whl/cu128/torch2.9/
# Run demo on video stream
python demo.py --model_path /path/to/checkpoint.pt \
    --video_path video.mp4 --fps 10
# Outdoor mode with sky masking
python demo.py --model_path /path/to/checkpoint.pt \
    --image_folder /path/to/images/ --mask_sky

Results are visualized in a browser via viser at http://localhost:8080.

Browser-Harness: AI‑driven browser tool generation

GitHub: https://github.com/browser-use/browser-harness

Problem

Most AI‑driven browser automation frameworks ship with a fixed set of ~100 tools; they cannot cover the constantly changing web, and adding a missing tool requires filing an issue and waiting for a maintainer.

Approach

The framework connects directly to Chrome DevTools Protocol via a WebSocket. When the AI encounters a missing function, it edits helpers.py on the fly and continues execution.

Example workflow

● agent: wants to upload a file
● helpers.py → upload_file() missing
● agent edits the harness and writes it
helpers.py 192 → 199 lines
+ upload_file() ✓ file uploaded

Code size and transparency

run.py

– ~36 lines, entry point helpers.py – ~195 lines, initial tool set that AI can extend admin.py + daemon.py – ~361 lines, WebSocket bridge to Chrome CDP

The code is fully auditable and has no hidden dependencies.

Domain Skills mechanism

When the AI discovers a site‑specific operation, it generates a “skill” file (e.g., under github/, linkedin/, amazon/) that can be reused on future similar tasks.

Free cloud browser

The project provides a free API key at cloud.browser-use.com that offers three concurrent browsers, suitable for sub‑agent deployment or CI/CD pipelines.

OpenMythos: Re‑creating Claude Mythos from first principles

GitHub: https://github.com/kyegomez/OpenMythos

Goal

Reconstruct the Claude Mythos architecture using only publicly available research; this is a community effort, not an Anthropic official release.

Core hypothesis

The original model is likely a Recurrent‑Depth Transformer (RDT), also called a Looped Transformer, which reuses the same weights across multiple forward passes instead of stacking many distinct layers.

Architecture

The looped transformer consists of three blocks:

Input ↓ [Prelude P]   — standard transformer layer, executed once
↓ [Recurrent Block R] — looped T times, hidden state h updated each round
↓ [Coda C]            — standard transformer layer, executed once
↓ Output

Stability is achieved by parameterising the recurrence as a linear‑time‑invariant (LTI) system.

Attention modes

MLA (Multi‑Head Latent Attention) – low‑memory variant used in DeepSeek‑V2.

GQA (Grouped Query Attention) – a variant of standard multi‑head attention.

The feed‑forward layer uses a sparse Mixture‑of‑Experts (MoE) that activates only the top‑mK experts per token, complemented by a shared expert for cross‑domain knowledge.

Model scales

mythos_1b: dim 2048, 64 experts, 16 loop iterations, 4k context

mythos_3b: dim 3072, 64 experts, 16 loop iterations, 4k context

mythos_10b: dim 4096, 128 experts, 24 loop iterations, 8k context

mythos_50b: dim 6144, 256 experts, 32 loop iterations, 8k context

mythos_1t: dim 16384, 512 experts, 64 loop iterations, 1M context

How to use

# Install the package
pip install open-mythos

# Load a configuration and run inference
from open_mythos import mythos_7b, OpenMythos
cfg = mythos_7b()
model = OpenMythos(cfg)
ids = torch.randint(0, cfg.vocab_size, (2, 16))
logits = model(ids, n_loops=4)
print(logits.shape)  # torch.Size([2, 16, 1000])

Intended audience

Developers and researchers interested in LLM architecture evolution and inference mechanisms, focusing on the reasoning pipeline rather than trained weights.