Unstructured input becomes structured value. Structure becomes relationships you can defend. Committees of models keep the answers honest, and domain workflows turn all of it into tools experts rely on.
Days of manual work → minutes. Source-attributed at every stage.
Work with us →HITS systems run on four layers. Ingestion engines turn messy input — PDFs, images, audio, scans, domain-specific documents — into structured, source-attributed data. Relationship layers link that data across the systems a business already runs, so every connection carries the evidence that justifies it. Agent committees turn the leading answer into the answer that survived structured attempts to break it. Workflow products turn all of it into tools domain experts rely on. We pick whichever stack fits the job — Tauri, React Native, Next.js, FastAPI, polyglot persistence. The sophistication isn't in any single layer — it's in the orchestration.
Route by task difficulty — the smallest model that actually works, prompt-cached, with the escalation path recorded. Accuracy is chosen per profile rather than paid for uniformly.
The schema is the contract. Extracted fields have operator, value, unit — actionable downstream, not just readable.
Every extracted fact links back to its source, and survives the join — an edge names the values that justify it, a figure names the query. Non-negotiable.
Domain experts (estimators, research nurses, genealogists) validate and refine. The model does the volume; humans keep the ground truth.
Eight products across six industries, and the four-service platform underneath them. Same conviction every time: an answer you cannot trace is not an answer.
Protocol Intelligence, BidEngine. High error cost, deep workflow moats, buyers who already know what the mistake costs them.
Layline. The coordination and memory layer — and the one the rest of the portfolio is already built with.
KindredKeep on the desktop, plus three mobile apps: Turnout, Bowler’s Palace, Lore of the Day. Won on friction and trust.
Chrona and the knowledge graph under Lore. Licensable engines and libraries that compound with use.
A 400-page protocol. One missed exclusion criterion.
Eligibility rules, visit schedules and assessment windows arrive as prose, spread across sections that quietly contradict each other. A coordinator reads all of it, builds a checklist by hand, and screens real patients against that checklist.
Ingests the protocol and produces structured eligibility rules, visit schedules, assessment workbooks, validation findings and cited protocol chat. Every artifact is one click from the page it came from, and the validation engine checks the eligibility section against the schedule of assessments to report where they disagree.
Research sites, sponsors and CROs running oncology trials. An enterprise sale with a long cycle — which is the moat, not the obstacle, because the buyer has already priced the error.
Nobody in clinical research will trust an AI summary; they will trust a finding that links to a coordinate in the PDF. The production build runs local-first, so identifiable patient data never leaves the workstation and the institutional privacy review that stalls most clinical software never has to happen.
Six packages on the desk. Time for four.
A commercial bid package is 170 to 400 pages of specifications, drawings with no text layer, addenda and rounds of Q&A. Most of the work is reading to find the relevant five percent, then tracing polygons on drawings to get a quantity. So the other two packages go unbid.
Produces a reviewable Bid Plan: package facts with the gaps stated outright, cited scope and exclusions, the drawing regions that matter, quantities with derivation traces, cost positions, an RFQ plan, and a closing list of the calls that need a human. Agents prepare and analyse; they never send, select a vendor, or finalise a price.
Specialty subcontractors bidding $1M+ commercial, institutional and government work — the firms with six packages open and an estimator who can only reach four. Uncovering a single unlisted scope exclusion pays for a year of software.
The real bar is not accuracy, it is verification cost: can an estimator check the work without it being faster to redo it? Every number carries its page, sheet and region, and adjusting one is a single click. It proves itself on public packages where the owner published the bid schedule — the only setting with a real answer key.
Your AI agents start every session with amnesia.
Product writes the spec in one tool. Engineering tracks the work in a second. The decisions rot in a third. And the agents actually doing the work open each session knowing none of it — so context gets re-explained, constantly, by everyone.
Collapses all of it into one git-backed workspace that humans and agents both read and write. Product defines a feature once; engineering picks it up with the context already attached; business sees real progress from the same source. A local-first desktop app plus an open-source CLI, with the workspace as a structured git directory you own outright.
AI-assisted engineering organizations — sitting in the gap between work trackers, knowledge bases and coding agents. Three categories that each hold a third of the picture and share no memory between them.
You own the workspace: it is a git repository, synced however you already sync git. Bring your own model keys, so it adds no model cost and no data leaves. And the authority model is the inverse of the category — agents read context and draft proposals, but never get implicit permission to edit, commit or push.
Your family history, hostage to a subscription.
The genealogy market is dominated by platforms that keep your tree in their cloud, on their terms, for as long as you keep paying. Meanwhile the documents that actually matter — the handwritten parish register, the immigration paper, the photographed headstone — sit in a box because nothing will read them.
A local-first desktop platform. Build the tree in Tapestry, archive media in Vault, read documents with Loom, research around the clock with Scout, ask questions in Campfire, hear stories in your ancestors’ voices with Echo, and merge trees across a family with Weave. GEDCOM in and out, free, always.
Privacy-conscious power users who want to own their archive outright — the audience that chose plain files over a cloud notebook. Free core, subscription for the genuinely expensive work.
Everything runs on the user’s machine, and the paid line follows real compute difficulty rather than artificial lock-in. Underneath, a matcher that fuses embeddings with string distance solves genealogy’s actual hard problem: surnames that were spelled differently every generation.
“Make an account to say you’re coming.”
Every RSVP tool asks your friends to sign up before they can answer a yes-or-no question. So half of them never answer, and the host ends up counting heads in a group text anyway. The failure is not features — it is the three seconds of friction between the link and the answer.
Tap the link, tap I’m In. No signup, ever. A cookie remembers you across events, a name is optional, and an account — if you ever want one — quietly absorbs everything you already did as a guest. Plus realtime chat per event, recurring series, QR check-in, plus-ones, and link previews that render properly in iMessage.
Crowded and low-retention, which is exactly why friction is the wedge — incumbents are ad-supported or calendar-heavy, and both make the guest do the work. Free to start; paid tiers unlock capacity, recurring series and presentation.
The product is its own distribution channel. Every invite recipient experiences the whole thing in one tap and becomes a candidate host — a recipient-to-host loop that costs nothing to run. Public events extend the same loop outward, with private-as-default kept deliberately intact.
No signal in the building. League money in a notebook.
Bowling alleys are concrete boxes, so most tracking apps stop working at the door. Behind the lanes there is a second, worse problem: a league secretary reconciling dues, brackets and side-pot payouts by hand, in cash, with no audit trail anyone can check.
Records a full session with no connection at all — scoring, history, statistics, frame and leave insights, and the ball arsenal you actually brought — then syncs when a signal returns. A separate operations app serves the people running things: seasons, rosters, schedules, dues, brackets and payouts.
The individual bowler is the acquisition channel; the league secretary is the customer. Brackets and side pots are where the money already moves, and collection, reconciliation and auditability are worth a transaction fee to the person currently doing it by hand.
Offline-first is an architecture decision, not a feature bullet — it is why the app works where competitors go blank. And it was built to look like a real product rather than a spreadsheet with a bowling pin on it, which is what gets it passed around in competitive league circles.
Forty minutes of scrolling, nothing to show for it.
The infinite feed is optimised to never let you finish, and people have started to notice how that feels. The alternative on offer is usually a chatbot — an empty prompt that answers confidently, cites nothing, and forgets the conversation the moment you close it.
One story a day, then structured cards if you want to keep going: what happened, why, the people, the primary evidence, and where the sources disagree. A finite daily ritual rather than a feed. Source, confidence and date are part of the story, not a footnote.
Consumers actively backing away from algorithmic feeds and looking for something deliberate to replace them. Free discovery, with an allowance metering genuinely new research.
The graph remembers. Research triggered by one person’s curiosity is cached and structured for everyone who follows, so the same question is instant and free the second time it is asked. Marginal cost falls as the library grows — cheaper to run and better to use at the same time.
Turn-based tactics, where you take turns.
The genre’s core convention is also its oldest limitation: you move, then I move, and nothing either of us planned ever actually collides. Multiplayer versions then desync because the rules run on floating-point math, and a replay from another machine quietly disagrees with yours.
Both sides commit orders and everything resolves on one shared timeline, tick by tick. Two units race for the same tile. A unit shot mid-move drops what it was doing. Fantasy V1 is the first game on it: command a frontier resistance across twenty missions, winning on terrain, deployment and timing rather than hero stats.
A tactical indie audience that rewards mechanical novelty over production budget. Two assets rather than one: the game, and the engine underneath it — built setting-neutral and separable so it can be licensed to other studios.
All rule mathematics is integer-only, enforced by a test that fails the build over a single stray decimal. Desync becomes impossible and a full replay stores as a seed plus inputs. The AI plays the scenario’s actual objectives and states a one-line reason for every move, which makes it debuggable and makes the game explain itself.
Each one is useful on its own, and none is nested inside a product — a substrate that belongs to one product isn't a substrate. Composed, they do something none of them does alone.
You can trace a value back to a pixel — that is what document AI sells. You can join that value into a warehouse and query it — that is what the data vendors sell. You cannot do both. By the time a number reaches a dashboard, nobody can say which page of which PDF it came from, whether the two records that got merged really were the same supplier, or which model decided. The provenance died at the join.
a value names the region and box it came from
an edge names the values that justify it
a figure names the query, and the query names its edges
Chained together, that is an unbroken line from a rendered pixel to a figure someone is about to act on. A number on a dashboard can be walked back to the page it came from. The fourth service is the gate the other three call whenever a claim matters enough to be defended.
Reads unstructured input through a staged, structure-first pipeline and returns records where every value names exactly where it came from — the region and box on a page, the speaker and timestamp in a recording, the part and span in a message.
Every job is priced before it runs, and a hard cap stops the job rather than surprising the invoice.
Deliberately generic: no taxonomy, no field names, no domain heuristics anywhere in it. All domain knowledge lives in customer-authored profiles, which are data — so it reads an invoice, a lab report, a lease or a scanned letter because it was never taught to expect any of them.
The generalized substrate the three ingestion engines converged on — KindredKeep on OCR variety, BidEngine on measurement, Protocol Intelligence on cross-artifact logic — extracted and offered as a service in its own right.
Connects to the databases and accounts a business already runs, and builds a governed graph over them and over Verso’s records. It proposes the relationships, resolves the same entity across sources, and enriches what it finds.
Nothing in it is a guess presented as a fact. Every edge carries the values that justify it and how it was arrived at. Every merge is a proposal with its evidence attached — reviewable, adjudicated where it matters, and reversible always. Merging records that describe people is never automatic.
Nothing is ever overwritten. Every fact knows when it was true and when we believed it, so “what did this cost the day we invoiced it” stays a question with an answer.
The answers a business wants are usually one join away and permanently out of reach. Every existing way of closing that gap — a warehouse, an MDM platform, a graph plus an ETL job — loses the reason two things are connected at the moment it connects them.
The front door. Connect your systems, describe what you need, and it compiles a plan: the profiles that read your documents, the model that links your data, the checkpoints where a decision has to be defended, and the dashboards, workflows, review queues and grounded chat on top.
A plan is configuration, never generated code. That distinction is the whole design — configuration can be checked against the contracts it targets, measured on your own data before it is allowed to run, versioned, diffed and rolled back. Generated code can do none of those, and can quietly step around every guarantee underneath it.
It drafts from shapes that have already worked, so it can say “not yet” to something it has no basis for. An honest refusal is a better product than a plausible plan that fails quietly.
“I’m a carpenter. I want to connect my accounting and photograph receipts, so I can see true cost per job and catch materials I never billed.” One sentence naming two systems, one entity that exists in neither of them, one relationship that has to be inferred, one number and one exception report.
Turns a source-bounded decision request into an explicit verdict — and keeps the evidence, the independent candidates, the challenges raised against them, the dissents and the provenance behind it.
It is not “ask several models and vote.” A committee is one mechanism inside a governed contract: focused evidence, independent candidates, adversarial challenge, deterministic checks, adjudication, then a verdict a human can review.
Abstention is a first-class outcome. A system permitted to say “I don’t know” is the only kind worth believing when it doesn’t.
Not a fourth stage — the gate the other three call before letting a material claim through. Protocol Intelligence first, for source-grounding and coverage review. BidEngine second, for evidence-backed scope findings. Every merge of records describing a person, without exception. The calling product always keeps data authorization, workflow and the final human decision.
Ten principles that shape every HITS product.
Route by task difficulty: smallest model that works for classification, mid-tier for extraction, largest only for validation. Cache system prompts. Never pay for reasoning you don’t need.
The schema is the contract. If a field isn’t structured — operator, value, unit — it isn’t actionable downstream. Design schemas with the end workflow in mind.
Single-pass extraction is a demo. Production systems dispatch adversaries to break their own output, and accept only on convergence.
Every extracted fact links back to its source document and page. Non-negotiable.
Failures happen. Systems resume from the last completed stage, not from scratch. State machines with atomic transitions.
Pick the right datastore for each workload — relational for truth, vector for semantic search, graph for relationships, local for local-first. Don’t unify for unification’s sake.
Data mutations emit events; independent consumers handle side effects without coupling.
For consumer software, the user owns the data. Cloud extends capability, not ownership.
Shared patterns across products are surfaced explicitly so sibling products don’t reinvent.
Ground truth from domain experts replicates slowly; code replicates fast. Build where domain expertise compounds.
Agent committees for the decisions that matter.
When a HITS engine reaches a decision worth doing right, it doesn't ask one model. It convenes a committee.
Different model families. Different priors. Different prompts. Each member produces a candidate answer with cited evidence. Candidates are scored against a domain-specific rubric. Adversaries try to break the leading answer. An independent judge — different from both — rules.
The committee returns:
When consensus, adversarial survival, source grounding, and schema compliance all pass, the answer is accepted. When any one fails, the answer is surfaced for human review with the strongest dissent visible.
There is no silent acceptance.
The pattern is not new to us. What is new is doing it deliberately, across verticals, under our own name.
Justin spent years building document-ingestion systems that ran in production — the kind that process work continuously rather than on demand, recover from partial failure without losing progress, and are judged on whether a downstream team can defend the output to someone who was not in the room. That work spanned the full width of the problem: getting text off pages that were never meant to be machine read, classifying what a document actually is before deciding what to do with it, extracting fields into schemas that hold up under validation, detecting sensitive material, and making all of it searchable and reviewable afterward. It also spanned the parts nobody demos — retry semantics, throughput under uneven load, the cost of a model call multiplied across a queue, and the operational reality that an extraction pipeline is only as good as its worst day.
Everything HITS builds is shaped by what that experience taught: that accuracy is necessary and insufficient, that a number without a source is a liability, and that the useful question is never “is the model right” but “can a domain expert verify this faster than doing it themselves.” The portfolio above is that lesson applied eight times.
Turnout runs today on real events with real guests — cookie-token RSVP, realtime chat, recurring series, and Stripe subscriptions. Not a prototype and not a pilot: a product with users, an on-call surface, and a manual-migration discipline that treats a schema change in git as unapplied until someone proves otherwise.
Chrona’s rule mathematics is integer-only, and a contract test fails the build over a single stray decimal — because one is enough to make a saved replay diverge on another machine. Every round is fingerprinted, so a replay is verified rather than trusted. Guarantees that are not mechanically enforced are just intentions.
Verso’s first phase closed against three exit criteria, each carrying named evidence rather than a status update: tenancy and row-level isolation, the ingestion boundary, provenance, an atomic budget grant, a provider registry, and an offline evaluation harness — 519 tests behind them. Nothing external runs without a measured evaluation first.
Founded by Justin and Stacy Howard.
Senior systems engineer specializing in the ingestion-engine pattern — turning unstructured data into structured, source-attributed workflows. He spent years building document-ingestion systems that ran in production before founding HITS, and has since shipped the pattern across clinical research, commercial construction, genealogy and generic document processing. HITS is him doing this deliberately, repeatedly, across verticals.
LinkedInStacy Howard is a co-founder of HITS. Her founder bio will be added in a near-future update.
Got a domain drowning in unstructured data? We design and build the ingestion engine that turns it into structured, source-attributed, production-grade workflows.
