Everyone has the same tools. The method is the difference.
The tools of this trade stopped being scarce. The same search, the same databases and the same machine assistance are available to anyone, including you. What separates one research practice from another is no longer access. It is method: what you look for, what you refuse to trust, and how honestly you report what you found.
Ours runs on a simple spine: a few decisions that get locked and are never argued backwards, and between them, loops in which machines do the work and people judge it. Here it is, in the order it actually runs.
The brief in writing: what you want to know, what a good answer looks like, how we both measure that we got there.
We look from outside. No house truths, no habits.
Only numbers that can honestly be compared.
Every fact arrives with a named source.
Search plan and data collection plan
- machine
- drafts the research plan: where to search, what to collect, in what order
- human
- judges it, redirects it, recommends; around again until the plan holds
Milestone. From here the plan is executed, not debated.
Collection, wide as the machines can reach
- machine
- searches, collects, files; verification running inside the whole time
- human
- steers against the plan; around again until the criteria from 0 are met
Consolidation and verification
- machine
- consolidates the material, runs the verification layer
- human
- reads, challenges, interacts; around again until the picture is solid
Milestone. What the finished work will contain is now fixed.
Analysis, recommendations, visualization
- machine
- executes: drafts, computes, renders the data human
- human
- iterates the judgment; and so on, the same figure, until it is true
Human-readable and machine-readable in the same document, ready to be acted on.
Reality, the last verifier
- world
- what actually happened, held against what we said would happen
The question is fixed before anything runs.
question := fixedBefore any search starts, the brief is written down and agreed: what you want to know, what a good answer would look like, and how we will both measure that we got there. Every loop below runs until those criteria are met, which is only possible because they exist in writing first.
This step is the company's name. An ansatz is a stated starting form you commit to and then compute forward from. We are named after step zero.
Three rules at the door.
Everything that enters the work passes three rules. Not virtues. Rules.
We look from outside
No house truths, no habits, no favourite department. Your question gets treated as a question, not as something half answered already.
Only numbers that compare
If two numbers cannot honestly be compared, they are not compared. Messy input gets cleaned until comparison is honest, however long that takes.
Every fact has a named source
Nothing enters without one. So any line of the finished work can be checked without asking us.
The machine drafts the plan. A person judges it.
The first thing the machines produce is not findings, it is a plan: where to search, what data to collect, in what order. A person judges that plan, redirects it, adds what only a person would think of, and sends it around again. The loop runs until the plan holds up.
The method is locked. Now it is executed, not debated.
method := lockedThe agreed plan becomes the method of this particular job, and it is a milestone: from here on it is executed, not reopened. If reality later proves it wrong, that is a finding in its own right, and it goes on the record like one.
Machines search as wide as machines can reach.
Registers, filings, published data, the open web: machines search, collect and file, with verification running inside the loop the whole time, so the material stays reliable as it grows. A person steers against the locked plan. The loop runs until the criteria from lock zero are met.
The material is consolidated and verified, together.
The machine consolidates what the search brought in and runs the verification layer over it. A person reads, challenges and interacts with the result, and sends it around again until the picture is solid. This loop is what makes the next lock possible.
The deliverable is defined before it is built.
deliverable := definedOnly when the picture is solid do we fix what the finished work will contain. Milestone number two, and the same discipline as the first: defined, then built, never the reverse.
Analysis, recommendations, visualization. Same figure again.
The machine executes: drafts, computes, renders. A person iterates the judgment: what matters, what not to trust, what it all adds up to, and what we recommend you do about it. Around again until it is true.
And when the facts do not support the answer you were hoping for, the document says so plainly. A null result is a deliverable here, not a failure, because knowing that something cannot be shown is worth exactly as much as showing it.
We make data understandable. And enjoyable.
Every answer ends as data, and data is where most reports go to die, so the step between the data and the person deciding is part of the method, not decoration: charts you read in one glance, numbers that keep their sources attached, and a visual explanation wherever one is possible. We will find one even in the most absurd cases.
We enjoy this part, honestly. It shows in the documents, and it is why a finding of ours is something you read rather than something you scroll past.
Delivered, and prepared to be acted on.
work := deliveredIf our intelligence ends up in actions, it is already prepared for them. Everything is documented so that a person can read it and a machine can ingest it, the same document, self-explanatory in both directions. When a finding needs to feed your CRM, your ad platform or your own spreadsheets, it goes in without translation work.
Reality is the last verifier.
Every recommendation ships with its expected outcome and the way to measure it. So one more loop runs after we hand over: what actually happened, held against what we said would happen. It is the one verification layer we cannot rig.
The ledger runs beside everything above.
Every step in the spine, machine or human, appends one line to an append-only ledger: every source admitted, every version, every lock, every verification pass, written as it happens and never edited afterwards. The finished work can be audited end to end, and so can the process that produced it. Not a promise, a file.
This much rigor is only possible because machines carry it.
Read the spine again and count the work: a plan drafted and redrafted, a search that never tires, verification inside every loop, a ledger line for every step. Done by hand, that discipline is what big consultancies charge big prices for. We can afford it because almost all of it is machine-outsourced, and the people spend their hours where people are the instrument: the locks and the judgment.
That division of labour is the whole economics of this practice, and it is why the rigor does not cost what rigor used to cost. The numbers are on the pricing page.
What we will not do.
No hacking. No pretending to be somebody we are not. No bought, leaked or scraped personal data. No following people. We work from what is public and lawfully accessible, and if an answer cannot be reached from open material, we tell you so instead of reaching for it.
This is not squeamishness. A finding whose origin you cannot show is a finding you cannot use: not in a negotiation, not in front of a board, not in front of a lawyer.
Evidence beats gut feel, and you can now test that cheaply.
A decision made with the evidence in front of it is a better decision than the same one made on instinct. That is the edge, and it is not ours: it belongs to whoever has the research in hand.
Depth like this used to be sold at big consultancy prices, which meant it was sold to big companies. The tools moved, and the barrier moved with them. What we sell is that depth at a size you can try: a short, inexpensive, measurable pilot that shows you whether the edge is real for your business before you bet anything on it.
And because the result is measurable, we can sell it the way we prefer to: wherever possible you buy a finished deliverable, not a promise. The terms are on the pricing page, and what we actually do is on Fields.