Dmitrii Calzago

Hot take on vibe-coding. We know that early writing systems, such as Sumerian cuneiform, were arcane, accessible only to professional scribes, and had very unimaginative uses: basically, used to keep track of how many sheep who owed in taxes (unsurprisingly, since that's what the scribes were hired to do). Then, as writing systems got simpler and literacy spread beyond professionals, the uses of writing multiplied, eventually leading to the novels and poetry we take for granted today, but which an ancient Sumerian scribe could scarcely have imagined. What if the same thing is happening to coding right now? Imagine that today's software systems are the equivalent of Sumerian sheep tax records. What will the software equivalent of Hamlet be, which universal access to coding might bring about?

64

7 Comments

Another night of AI slopping with ideas... I have been thinking a lot about how easy it is for both humans and AI agents to jump from a market headline to a polished explanation without leaving much of a reasoning trail behind. So I built Signal Graph, a local, CLI-first trading research toolkit for turning a raw market event into an explainable hypothesis with explicit provenance. It is not a trading bot or an execution engine. The goal is much simpler: create a workflow where a human or agent can move from event capture to research, graph reasoning, ranking, and memo generation without hiding the evidence chain. Built with Python and Neo4j. If you are working on AI agents, research tooling, or explainable decision-support systems, I would love your thoughts.

33

1 Comment

Here's an article I would have found useful when I was first trying to understand how the attention mechanism in LLMs / transformers actually works. There are already great explanations of transformers and attention out there. Jay Alammar's Illustrated Transformer is excellent, and Attention Is All You Need is more readable than people expect. This piece is my attempt to connect the dots between the math and prompting. The key idea is simple. Once you understand how attention computes relevance between tokens, prompting stops feeling like guesswork. You start to see why being specific helps, why chain-of-thought improves reasoning, and why instruction placement in long prompts matters. To make it more digestible, I built a few interactive visualizers so you can watch tokens get embedded, see attention scores form, and step through the prediction process yourself. If you've ever wondered what's really happening when you hit "send" on a prompt, this might be useful. https://lnkd.in/gApqTxAh

19

1 Comment

🚀 Introducing: LLM Registry Enterprise-grade infrastructure for managing LLM assets at scale. As teams move from experimenting with models to running real LLM systems in production, one problem keeps showing up: 👉 Where do models, datasets, pipelines, policies, and tests actually live… and how do you govern them? LLM Registry is the answer. 🔐 What it does Centralized, version-controlled registry for: Models, Pipelines, Datasets, Policies, Test suites Dependency tracking, provenance, and compliance baked in 👨‍⚖️🎂 🧠 Why it matters❓ LLM systems are no longer just prompts and APIs. They’re now: • Audited • Versioned • Multi-asset • Policy-constrained • Continuously evolving LLM Registry brings software-grade discipline to LLM operations. ⚙️ Core capabilities • Real-time lifecycle events via NATS • Full asset versioning & lifecycle management • SHA-256 integrity verification & provenance tracking • Policy-based governance & compliance enforcement • Automatic dependency resolution + circular detection 🔐 Enterprise-ready by default • Secure REST APIs • JWT auth + API keys • Distributed rate limiting • RBAC with permission inheritance 📊 Production observability • Prometheus metrics • Health & readiness probes • OpenTelemetry tracing (Jaeger) • Structured logs with correlation IDs ⚡ Built for performance • Rust + async I/O • P99 latency <50ms • Redis caching (>90% hit rate) • Stateless, horizontally scalable 🧩 Developer-first • TypeScript SDK • Modular Rust crates • CLI for automation & CI/CD • Docker & Kubernetes ready This is registry, governance, & control-plane infrastructure for serious LLM platforms. If you’re building: • Enterprise AI systems • Regulated or multi-tenant AI products …this layer becomes non-optional. For My Ai Nerds: 📦NPM: Registry: https://lnkd.in/eNG-H-Qp SDK: https://lnkd.in/erwakwtH 🦀Crates: Registry API: https://lnkd.in/e5ix-DEd Core: https://lnkd.in/ebAaTdn6 DB: https://lnkd.in/e2scYPK5 Server: https://lnkd.in/eQcEEchg Service: https://lnkd.in/eCGRdHnR #LLMDevOps #AgenticEngineering #OpenSource #Rust #NPM

16

2 Comments

I think Sam Altman, in his recent interview, essentially agreed with my paper “Turing Test 2.0: The General Intelligence Threshold”! He proposed that if a future AI model could “…figure out quantum gravity and could tell you its story,” that would indicate that AI has achieved AGI, and that a truly creative AI would “…come up with new scientific knowledge”. This perfectly aligns with the framework I proposed for testing AGI. I define AGI as the ability to generate new functionality by applying new knowledge that was not previously introduced through training. My framework (Turing Test 2.0) generates tests that can determine if a model has achieved AGI in a simple fail-pass result. I even present some examples of applying these tests to popular LLMs! Having a precise and measurable definition for AGI can help us better understand how close we are to achieving this goal. If you want to learn more about my work, you can read my paper, or you can listen to me discuss my work with Prof. Robert J. Marks in his podcast MindMatters in a three-part series (links below). You can read my paper here: https://lnkd.in/gStXD_pF You can listen to me talk about my work here: Part 1: https://lnkd.in/g-_tzJZt Part 2: https://lnkd.in/gdnZX6pz Part 3: https://lnkd.in/gaCBzPvZ Sam Altman’s interview: https://lnkd.in/gtENirSu

29

1 Comment

What is KV cache, and why is it critical for local LLM inference? When people talk about running an LLM locally, they often focus on one thing: The size of the model weights. “Can my GPU load a 7B model?” “Can I run a 13B model in 4-bit?” “How much VRAM does the model require?” But that is only part of the equation. During inference, the model also requires runtime memory. A significant part of it is used by the KV cache. The KV cache stores the Keys and Values already computed by the model’s attention layers. Its purpose is simple: Avoid recomputing the previous tokens every time the model generates a new one. Without the KV cache, generation would be considerably slower. With it, the model reuses information it has already computed. But there is a trade-off: The KV cache consumes memory. Its memory usage mainly depends on: • the number of cached tokens • batch size and concurrent sequences • the number of model layers • the number and dimensions of KV heads • cache precision, such as FP16, FP8 or INT8 A simplified estimate is: KV cache memory ≈ 2 × layers × KV heads × head dimension × cached tokens × batch size × bytes per element The 2 represents the Keys and Values. The exact memory usage can vary depending on the model architecture and inference engine. This is why a model may fit in VRAM with a short prompt but become difficult to run with a longer context window or multiple concurrent users. Model-weight memory is mostly fixed once the model is loaded. KV-cache memory grows with context length and the number of concurrent sequences. This makes it especially important for: • chat assistants • RAG pipelines • document analysis • AI agents • long prompts • multi-user inference So when sizing local infrastructure, the real question is not only: “Can the model weights fit in VRAM?” It is also: “Can the complete inference workload fit with my actual context length and usage pattern?” That is exactly why we built a tool based on LLMFit to estimate which LLMs can be hosted on your infrastructure. It also provides useful information such as: • model license • model provenance • usage restrictions • local hosting feasibility I’ll share the link in the comments. Because local inference is not just about loading a model. It is about knowing whether you can actually run it properly. #LLM #LocalAI #Inference #MLOps #GenAI #OpenSourceAI #AIInfrastructure

2

1 Comment

GLOBAL WARNING. When an AI frontier lab steps out of digital simulations and into physical wet labs, the conversation shifts from software benchmarks to biological reality. Anthropic mime AI artist Claude is now running physical wet-lab experiments at its own facilities in the San Francisco Bay Area. According to Eric Kauderer-Abrams, Anthropic’s head of life sciences, the objective goes well beyond standard compute - the ambition is to have Claude direct robotic laboratory hardware through physical protocols with limited direct human intervention. While Anthropic maintains that human oversight remains central to their safety guardrails, this transition marks a major inflection point:- Closing the simulation gap: In silico models are powerful, but biological complexity often defies pure software predictions. Physical automation allows models to test hypotheses, observe real physical feedback, and iterate rapidly. Tackling underserved biology: While not framed strictly as commercial drug discovery, Anthropic is exploring preclinical research targeting diseases that traditional pharmaceutical pipelines overlook due to margin or scale constraints. The new safety perimeter: The frontier risk profile changes entirely when an autonomous model is granted write-access to physical matter. Managing biological safety and dual-use biosecurity moves from hypothetical policy papers directly onto the lab bench. Allowing language models to direct physical pipettes, synthesis, and execution represents immense therapeutic upside, but it also collapses the buffer between algorithmic error and real-world impact. #ArtificialIntelligence #Biotech #LifeSciences #Anthropic #BioSecurity #AIethics

29

17 Comments

We’re leaving the era where simply adding more compute reliably produces proportional gains in model quality. For years, bigger models and larger GPU budgets translated into clear improvements. That assumption shaped how AI systems were built and funded—but it’s breaking down. More compute still matters, but its role has changed. It remains useful for deployment efficiency, lowering latency, improving throughput, and stabilizing large-scale training runs. It also helps in certain workloads where parallelism scales cleanly. However, the idea that model capability will continue to improve in a near-linear way just by adding more GPUs is increasingly disconnected from reality. At scale, systems run into limits that are not about model architecture but about hardware itself: memory bandwidth, interconnect overhead, power constraints, thermal ceilings, and the widening gap between theoretical peak performance and what you actually get in training. This makes the hardware lottery more severe. Each new GPU generation comes with a higher price, yet real-world gains are often modest. In a near-monopolized market, access to hardware increasingly determines outcomes. Teams with equal talent and ideas can see very different results simply based on infrastructure. Unsurprisingly, large players are building their own chips. When hardware becomes a strategic bottleneck, waiting on vendors is no longer viable—custom accelerators become a necessity, not a luxury. Google with TPUs, Anthropic with their Chips, Tesla with their Chips and the list goes on. At frontier scale, hardware constraints become strategic constraints, and there’s only so long you can wait for external vendors to solve problems that directly block your progress. As compute-driven gains slow, value shifts toward data. High-quality, domain-specific data now drives progress more reliably than brute-force scaling. Synthetic data can’t fully replace this, since models can’t generate knowledge they don’t already possess. Much valuable information remains undigitized, inaccessible, or unstructured. Synthetic data does not fully replace this. Models cannot generate what they do not already understand, and bootstrapping from existing models often amplifies biases and gaps. Much of the world’s most valuable information is still inaccessible—locked in paper archives, unscanned documents, internal systems, or poorly indexed sources. In many cases, this data cannot be realistically recreated or discovered through synthetic means. When hardware progress slows and compute becomes increasingly expensive, the advantage shifts upstream. Not toward more data in general, but toward better data—data that is verified, structured, and grounded in reality rather than model-generated approximations. The hardware lottery doesn’t just slow down AI progress; it changes what progress depends on. And right now, that dependence is moving decisively toward foundation.

9