A useful agent trace is not a list of timestamps. It is a causal tree. When a TypeScript agent retrieves documents in parallel, calls a model, retries a tool, and falls back to cached data, each operation needs a trace ID, its own span ID, and the correct parent span. Without those relationships, completion order is easily mistaken for execution structure. This article builds a small Node.js tracer to demonstrate the core mechanics: immutable async context, parent-child spans, reliable finalization, and a pluggable sink. It is intentionally smaller than a production observability library, but the design avoids several common mistakes found in minimal examples. Completion Order Is Not Causality Imagine three tools running in parallel: 80 ms search_tickets completes 100 ms load_account completes 120 ms search_docs completes Those timestamps describe completion order. The execution tree describes why the operations existed: research_agent └─ parallel_retrieval ├─ search_docs ├─ search_tickets └─ load_account Both views are useful, but only the tree preserves the relationship between the agent decision and its child tools. The normal JavaScript call stack cannot serve as that tree. Async work may resume later, execute concurrently, or outlive the function that scheduled it. Tracing therefore needs an explicit logical context. The Context We Need Each asynchronous branch needs two values: type TraceContext = { traceId : string ; parentSpanId : string | null ; }; When a new span starts, it reads the current context, records parentSpanId , creates its own spanId , and runs child work inside a new context whose parent is that span. In Node.js, AsyncLocalStorage provides the propagation primitive. It carries a value through normal asynchronous resources without adding trace parameters to every application function. Do not mutate one shared context object. Parallel siblings would race to replace the current span. Create a new context value for every nested span instead. Defin

We Open-Sourced Both Halves of Our Security Stack — Detection and Deliberation AEGIS catches the threat. ENLIL decides what it means. Both are free, and we want to know if they actually help you. We've written before about each of these projects separately — AEGIS's post-quantum forensic logging and why ENLIL runs 9 LLMs in parallel instead of one . This post is about why they're actually one system, and why we're not gatekeeping either half of it. Two different jobs AEGIS is an intrusion detection/prevention system. It watches traffic, correlates signals across nine layers (from crypto-level filtering to adaptive moving-target defense), and decides — fast, locally, without calling out to anything — whether something is an attack. It's deliberately narrow: detection and containment, nothing else. No counterattacks, no active reconnaissance, one process, deployable on a standard VPS. ENLIL does the opposite job. It's slow by design — it convenes a council of independent LLMs, lets them reason in isolation (no model sees another's answer until synthesis), and produces a signed Decree: the majority view, the dissents, and a final verdict. It's built for the decisions where being fast and wrong is worse than being slow and right. Neither one replaces the other. AEGIS shouldn't spend 30 seconds deliberating about whether a SYN flood is a SYN flood. ENLIL shouldn't be making split-second network decisions. But there's an obvious seam between them: what happens when AEGIS catches something that isn't a simple yes/no — a pattern that's ambiguous, or severe enough that you want more than one model's opinion before you act on it? The Bridge That seam is a small connector: when AEGIS's detector layer flags something at high or critical severity, it fires a signed event at ENLIL's API. ENLIL convenes a tier of the council sized to the severity — a lighter tier for routine escalations, the full council (including the most expensive model) only for the things that deserve it. The

“We're in the realm where we might be essentially killing off everything within that first hour or two."

I finally shipped the first version of my freelance landing page. The funny part? I spent weeks thinking I had a design problem. I didn't. I had a content problem. The layout is good enough. The copy is good enough. The CSS is good enough. What the page really needs now is more real projects. Instead of redesigning it again, I'm going to spend my time replacing concept work with actual client work as it comes in. Sometimes the next version isn't another refactor. It's simply experience. 🔗 https://lksvn.com.br/freelance/

Before we start This is a series about the intermediate results of an ongoing effort, not a finished story. It isn't an academic paper — it's a record of real engineering work and the insights that emerged along the way. Also, it's not about AI generating code. The AI angle here is about investigation and research — a careful, governed use of AI as a tool, not an autopilot — something I'll come back to in the final part. A word on why now, with the project still unfinished: details fade — the small technical decisions, the intermediate observations, the context in which a given call was made. Writing this down while the work is still ongoing is partly how I keep that context from slipping away. And that context matters: it's a reminder that every past decision, mine or anyone else's, was made for reasons that made sense at the time. One more note: none of this happened instead of product work. All of it ran alongside building new features and fixing bugs — the roadmap never paused for it. On confidentiality: I don't name the Customer, and I avoid any personal data or details a competitor could use. For the same reason, I don't mention anyone by name and refer to colleagues only by role. I won't name them, but I want to acknowledge up front that much of what follows was only possible thanks to the people I work with. The numbers are approximate and rounded — the point is the order of magnitude and the reasoning, not the exact figure. And a framing to carry through the series: at this scale, optimization is less a sprint than a marathon — yes, probably the most overused metaphor around, but here it genuinely fits: steady pacing beats sprinting, and you get there one careful step at a time. How I ended up here I'm a software engineer, and I've spent most of my career close to backends and databases. I've also led teams as a technical team lead — though over time I've deliberately shifted back toward more hands-on technical roles, which is where I'm most effective and m

Runlayer is suing Rippling after Rippling evaluated the startup's MCP gateway product and then opted to build one itself.

The final condition will shock you! (It won’t. It’s taxes.)

submitted by /u/Refresh98370 [link] [留言]