Archive
1046 posts · Page 45 of 88. ← Blog
Valuation feels like it should be a fact — what the company is "worth" — but for an early-stage startup with little revenue and an uncertain future, there is no objective number to discover. Valuation is a negotiated price, not a measurement, and understanding that changes how you think about it: it's the price at which you sell ownership, it directly determines how much you're diluted, and chasing the highest possible number can quietly work against you. This post demystifies where valuations come from and why the number matters less than founders think and differently than they expect.
Valuation feels like it should be a fact — what the company is 'worth' — but for an early-stage startup there's no objective number to discover. Valuation is a negotiated price, not a measurement: it's the price at which you sell ownership, it directly determines your dilution, and chasing the highest number can quietly work against you.
A technically excellent model is worthless until it changes a number someone cares about. Here is how to design backward from that number.
Why technically excellent models never ship: no clear business metric, organizational buy-in, validation and model-risk sign-off, monitoring, and the prototype-to-production chasm.
An agent that burns its turn budget without finishing is neither a success nor an error. Give it a distinct outcome and a typed event stream.
The scariest agent failure is the runaway loop that never finishes. Cap every run at max_turns and make EXHAUSTED a first-class outcome, neither a failure nor a silent success, with a typed event stream you can route on.
Lesson 4 of Harness Engineering in Go — three collaborating stores (a thread, a knowledge index, and a summarizer) behind interfaces, and an honest accounting of where each local stand-in leaks.
Lesson 4: memory is three stores, not one — an append-only thread, a keyword knowledge index, and a lossy first-and-last summarizer — and an honest account of where each local stand-in leaks against Azure.
In C, a type is a promise about how many bytes a value occupies and how to interpret them. There's no hidden bignum, no automatic string, no safety rail — just fixed-width integers, floating-point, and the bit patterns underneath. Understanding C's types means understanding sizes, signedness, and the surprising rules of integer promotion, because in C the difference between `int` and `unsigned` can be the difference between correct and catastrophically wrong.
In C, a type is a promise about how many bytes a value occupies and how to interpret them — no hidden bignum, no safety rail, just fixed-width integers and the bits underneath. Understanding C's types means understanding sizes, signedness, and the surprising rules of integer promotion, where the difference between int and unsigned can be catastrophic.
The single most misunderstood thing about startup ownership is what happens to your slice when you raise money. Founders imagine they're "giving up 20%" and keeping a fixed 80% forever — but ownership isn't a slice carved from a fixed pie; it's a percentage of a share count that keeps growing. Every round issues new shares, and every new share makes everyone's existing percentage smaller. Understanding this — dilution, the cap table, and the option pool — is understanding what you actually own, and it's where founders most often get an unpleasant surprise.
The most misunderstood thing about startup ownership is what happens to your slice when you raise. Ownership isn't a slice of a fixed pie; it's a percentage of a share count that keeps growing. Every round issues new shares, and every new share makes everyone's percentage smaller. That's dilution — and it's where founders most often get an unpleasant surprise.
Financial ML lives under regulators, adversaries, and money-denominated errors — so you design backward from a business metric, not forward from a model.
What sets financial ML apart from general ML: strict regulatory scrutiny and mandatory explainability, high-stakes and immediately quantifiable errors, messy multi-source data, non-stationarity, and adversarial actors.
If your gateway will block a tool call, don't make the agent discover that by trying. Hand it a capabilities brief and stop paying for turns it can't complete.
If your gateway will block a tool call, don't make the agent find out by trying, because each blocked attempt is a wasted turn. A capabilities brief aligns what the model thinks it can do with what enforcement actually allows.
The reference capstone for the 26-part series — every canonical ADK term, defined concisely.
The capstone of the series: every core ADK concept defined in one place — agents and orchestration, tools, sessions/state/memory, context and callbacks, runtime and streaming, models, grounding, evaluation, protocols, and deployment.
Lesson 3 of Harness Engineering in Go — how a context deadline and `exec.CommandContext` reap a runaway snippet, why the two-shaped `Result` distinguishes a timeout from a failure, and the leak that makes a local subprocess a teaching tool, not a security boundary.
Lesson 3: run agent-written code behind a hard timeout with exec.CommandContext, distinguish OK from TimedOut, and face the leak — a subprocess is not a security boundary.
C is fifty years old and still runs the world — operating systems, databases, language runtimes, embedded devices, and the standard libraries under almost everything else. Learning C is learning how computers actually work: memory, pointers, and the thin layer between your code and the machine. This series builds C from the ground up, and it starts with what C is and what really happens when you compile it.
C is fifty years old and still runs the world — operating systems, databases, language runtimes, embedded devices. Learning C is learning how computers actually work: memory, pointers, and the thin layer between your code and the machine. This series builds C from the ground up, starting with what C is and what really happens when you compile it.
The lettered rounds — pre-seed, seed, Series A, B, C — sound like a fixed ladder every startup climbs, but they're really names for stages of risk and proof. Each round exists because a company has reduced a specific kind of uncertainty since the last one, and each is meant to fund reducing the next. Understanding what each stage is actually for — not just what it's called — tells you why a company raises when it does, how much, and what it needs to prove to raise the next.
The lettered rounds — pre-seed, seed, Series A, B, C — sound like a fixed ladder, but they're really names for stages of risk and proof. Each exists because a company has reduced a specific uncertainty since the last one. Understanding what each stage is *for* explains why a company raises when it does, how much, and what it must prove.