Alpha software. Augur is a local-first account-intelligence workspace under active development. Build from source for evaluation; there are not yet signed public installers or a stable release channel. “OS” is the product name, not a claim that Augur is an operating system or extension platform.
A local-first lead-intelligence workspace that turns a cold company name into a fully researched, evidence-backed, scored opportunity in minutes.
- What is Augur OS
- The problem
- Features
- Who it is for
- Product tour
- How it works
- Architecture
- Project structure
- Tech stack
- Getting started
- FAQ
- Contributing
- Security
- License
Augur OS is a desktop application for B2B account research and signal-based lead scoring. You give it a list of companies. For each one it runs a deep, multi-stage research pipeline, scores the account against your own ideal-customer rubric, maps the real buying committee, and drafts outreach grounded in cited evidence. Work that used to take an afternoon per account finishes in minutes.
What sets it apart is discipline. Augur does not just generate a plausible-sounding summary. A bounded verification stage audits the evidence metadata supplied by research specialists and drops or weakens unsupported claims. The verifier does not independently fetch every source today, so citations remain reviewable evidence—not a guarantee of factual correctness.
Augur runs as a native desktop app built with React 19, TypeScript, Tauri 2, Rust, and SQLite. Your research, scores, and pipeline live in a local database on your machine. There is no Augur-operated server, but research prompts and account data are sent to the Claude service through your local Claude CLI; Apollo enrichment sends requested contact data to Apollo when enabled.
Outbound teams spend more time researching accounts than selling to them, and they still walk into conversations half-blind.
The research itself is slow and repetitive. A rep opens a dozen browser tabs, skims the company website, scans recent news, guesses at who sits on the buying committee, and tries to find a reason the deal is urgent right now. An hour later they have a thin set of notes and no real confidence in them.
The output is also hard to trust. Generic AI summaries read well but quietly invent facts, average away contradictions, and cite nothing. A confident sentence with no source behind it is a liability in a sales conversation, not an asset.
And the prioritization is guesswork. Without a consistent way to score accounts, reps work the names at the top of the list instead of the names most likely to close.
Augur OS attacks all three problems at once: it does the research fast, it grounds every finding in a checkable source, and it scores each account against a rubric you define so your team works the right deals in the right order.
-
Deep company research. For every account Augur works out the business model, what the company sells, how it makes money, who buys from it, where it is feeling operational pain, recent buying triggers, the technology stack, and competitive position. Each angle is researched in genuine depth rather than reduced to a single line.
-
Reviewable evidence. A dedicated verifier stage reviews every finding the research agents produce, checks its supplied URL and evidence metadata, weighs confidence and freshness, and rejects or weakens unsupported, stale, or contradicted findings. The verifier is bounded and does not independently fetch every URL; open important citations before acting on them.
-
Enforced citation contract. Standard and Deep runs must produce a strict verifier ledger. The Rust completion gate refuses malformed ledgers and will not accept a
verifiedclaim without a credential-free HTTPS URL, a substantive evidence quote, a bounded confidence score, and a valid date. Accepted receipts are persisted separately from the generated profile for audit. This validates the evidence contract; it still does not independently prove the source content. -
Signal-based lead scoring. Define your ideal customer once as a rubric. Augur grades every company from 0 to 100 against that rubric and shows the full reasoning behind the number, so the score is something you can defend in a pipeline review rather than a black box.
-
Buying-committee discovery. Augur finds the people who actually matter at each target, with their roles and the context for why each one is worth reaching, instead of dumping a flat list of names.
-
Grounded outreach drafts. Augur turns the research into a concrete outreach strategy for the account. Because the strategy is written from the same cited findings, every message is specific to that company rather than a generic template.
-
Live-streaming progress. Watch the research happen in real time. As each agent works, its progress streams into the app so you can see exactly what is being investigated and follow the run as it unfolds.
-
Local-first by design. Every lead, person, score, and prompt is stored in a SQLite database on your machine. Your pipeline is yours, and it works the same whether or not you are online when you read it.
- Outbound and SDR teams that need to research and prioritize a large list of accounts without burning a day per company.
- Account executives preparing for discovery calls who want a defensible account brief, a mapped buying committee, and a clear reason the deal is timely.
- Founders running their own outbound who do not have a research team and need to punch above their weight on every account.
- RevOps and sales leaders who want a consistent, rubric-driven scoring model so the team works the same definition of a good-fit account.
- Anyone who values local-first software and wants their prospect research to stay on their own machine.
Your pipeline at a glance. Every company, its research status, and its score in one workspace.
A research profile, written for you. Each account gets a TL;DR and a full profile distilled from the run.
Evidence behind every claim. Cited sources back each finding, so you can trust what is in the profile.
The buying committee, mapped. See who to reach at the account and why each person matters.
Outreach, drafted from the research. A concrete strategy for the account, grounded in what Augur found.
A score you can defend. Every company graded against your rubric, with the full reasoning shown.
Augur runs each company through a multi-stage research pipeline. The pipeline is built around one principle: many specialists research in parallel, an auditor checks their work, and only verified findings reach the final profile.
When a research job starts, an orchestrator plans the run. It picks the right roster of specialist agents for the chosen research depth, sets up an isolated workspace on disk for the job, and coordinates the agents in ordered waves. Independent specialists in the same wave run in parallel; later waves do not begin until the artifacts from the previous wave are written to disk.
Each specialist owns exactly one research angle and writes its findings as a strict JSON artifact:
- Pain diagnostician finds public evidence of operational friction, costly problems, and buying urgency.
- Business-model strategist works out what the company sells, how it makes money, and who buys from it.
- Trigger-signal analyst surfaces recent events that make a deal timely, such as funding, launches, hiring, or leadership changes.
- Tech-stack analyst identifies the technologies the company runs.
- Competitive-position analyst maps where the company sits against its rivals. This specialist joins on deeper runs.
- People finder identifies the buying committee, with roles and outreach context.
Every specialist is told to prefer primary sources, attach an evidence URL to each non-obvious claim, and never invent a finding. If the evidence is weak, the specialist lowers its confidence or returns nothing rather than guessing.
The verifier reads every specialist artifact and audits each claim's supplied evidence metadata: URL, confidence, freshness, and cross-specialist conflicts. It does not perform a second web crawl or independently inspect every URL. Uninspected claims should be weak unless corroborated; unsupported or contradictory claims should be rejected. The synthesizer must respect the resulting ledger, but users should still open material citations before relying on a profile.
The synthesizer writes the final output. It reads the verified findings, applies a strict conflict hierarchy (verifier verdict first, then higher confidence, then fresher source, and otherwise drop the claim), and produces three artifacts: a structured company_profile.md with a TL;DR and sections covering what the company sells, how it makes money, who buys, current pain, recent triggers, tech stack, competitive posture, and a decision-maker map; a people.json file describing the buying committee; and an enrichment.json file of verified company fields. Claims in the profile are cited inline back to the specialist that produced them.
Scoring is a separate, deterministic step. You define your ideal customer once as a rubric. The scoring engine grades the researched company against that rubric, returns a 0 to 100 score, and shows the reasoning behind it. Because scoring runs against your own criteria, the number reflects your definition of a good account, not a generic notion of company quality.
flowchart TD
A[Company name] --> B[Orchestrator plans the run]
B --> C{Specialist wave - parallel}
C --> D1[Business model]
C --> D2[Current pain]
C --> D3[Buying triggers]
C --> D4[Tech stack]
C --> D5[Competitive position]
C --> D6[Decision-makers and people]
D1 --> E[JSON artifacts on disk]
D2 --> E
D3 --> E
D4 --> E
D5 --> E
D6 --> E
E --> F[Verifier audits claims vs evidence]
F --> G[Synthesizer writes profile, people, enrichment]
G --> H[Scoring engine grades vs your rubric]
H --> I[0 to 100 score with reasoning]
Each run has a depth setting that controls how thorough it is.
- Light runs a single-pass research session and skips the orchestrated specialist waves.
- Standard orchestrates five specialists, then a verifier, then a synthesizer.
- Deep expands the wave to add the competitive-position analyst and a buyer-profile synthesizer, runs the verifier across all prior outputs, and finishes with the synthesizer.
Deeper runs allow more time per job and produce a richer profile; lighter runs finish faster. You pick the trade-off per run.
Augur OS is a Tauri 2 desktop application. A React front end talks to a Rust core over Tauri's IPC layer. The core manages a concurrent job queue, persists everything to SQLite, streams progress back to the UI, and spawns research subprocesses to do the work.
flowchart LR
subgraph UI[React 19 front end]
Z[Zustand state]
R[Radix UI + Tailwind 4]
end
subgraph IPC[Tauri IPC]
CMD[Commands]
EVT[Events]
CH[Streaming channels]
end
subgraph CORE[Rust core - Tauri 2]
Q[Job queue - 5 concurrent]
DB[(SQLite - WAL mode)]
end
CLI[Claude CLI subprocesses]
UI -->|invoke| CMD
CMD --> CORE
Q --> CLI
CLI -->|stream output| CH
CH --> UI
Q --> DB
CORE -->|emit| EVT
EVT --> UI
The interface is built with React 19, TypeScript, Vite, and Tailwind CSS 4, using Radix UI primitives for accessible components. Application state lives in Zustand stores with Immer, and entities are kept in normalized Map collections keyed by id for fast lookups and updates. The stream panel keeps job logs in its own store so live research output survives navigation between views.
The front end and the Rust core communicate over Tauri's IPC bridge. There are three channels of communication: the UI calls backend commands with invoke; the backend pushes streaming channels carrying live job output as it is produced; and the backend emits events such as lead-updated and person-updated that the front end listens for to refresh its cached data reactively.
The core is written in Rust on Tauri 2. It owns the database, the job lifecycle, event emission, and the research subprocesses. Command handlers cover lead, person, and score CRUD, research and scoring job management, and prompt storage.
Research and scoring jobs run through an async job queue that allows up to five jobs at once, gated by a semaphore. Each job runs with a depth-dependent timeout. The queue handles spawning subprocesses, streaming their output, parsing results, and recovering cleanly if a job fails.
All persistent data lives in a local SQLite database running in WAL mode, accessed through rusqlite. It holds leads, people, prompts, scoring configuration, and lead scores. The database file lives under your local application data directory.
The research engine runs as Claude CLI subprocesses spawned by the job queue. Each research job gets its own isolated workspace directory containing the specialist agent definitions and an outputs folder. Specialists write their JSON artifacts and stream logs into that workspace; the core reads the results back and persists them. Workspaces are cleaned up when the job finishes.
src/ # React front end
├── pages/ # Page components (list, detail, scoring, prompt)
├── components/
│ ├── ui/ # Radix-wrapped primitives (Button, Dialog, etc.)
│ ├── leads/, people/ # Feature-specific components
│ └── stream-panel/ # Real-time job output display
└── lib/
├── store/ # Zustand stores
├── tauri/ # Backend integration (commands, event bridge)
└── hooks/ # Data fetching hooks
src-tauri/src/ # Rust backend
├── commands/ # Tauri command handlers
│ ├── database.rs # Lead/Person/Score CRUD
│ ├── research.rs # Job management (research, scoring)
│ └── prompts.rs # Prompt storage
├── db/ # SQLite schema and queries
├── jobs/ # Async job queue
├── prompts/ # Specialist and default prompt templates
├── orchestration.rs # Research depth, waves, workspace setup
└── events.rs # Event emission to the front end
| Layer | Technology |
|---|---|
| Front end | React 19, TypeScript, Vite, Tailwind CSS 4 |
| State and UI | Zustand, Immer, Radix UI |
| Core | Rust, Tauri 2 |
| Storage | SQLite (WAL mode) via rusqlite |
| Toolchain | Bun |
| Research engine | Claude CLI |
Before you build Augur OS, install the following:
- Bun: the package manager and script runner for the front end.
- Rust: the stable toolchain, used to build the Tauri core.
- Claude CLI: the research engine, with API access configured.
- Platform build dependencies for Tauri 2: system libraries vary by operating system. Follow the Tauri prerequisites guide for macOS, Windows, or Linux before your first build.
Confirm the Claude CLI runs from your terminal before starting Augur, since the research pipeline spawns it directly.
git clone https://github.com/DivyamTalwar/Augur.git
cd Augur
bun install
bun run tauri:devbun run tauri:dev starts the Vite dev server and the Tauri shell together with hot reload. The first run compiles the Rust core and can take a few minutes; later runs are fast.
bun run tauri:buildThis produces a native installer for your platform.
bun run dev # front end only (Vite dev server)
bun run lint # lint
bun run lint:fix # lint and autofix
bun run format # format with Prettier
tsc -b # type-checkWhere is my data stored? In a local SQLite database in your operating system's application data directory. There is no Augur-operated server. Research still leaves the machine through the Claude CLI, and Apollo enrichment leaves the machine when that optional integration is enabled.
Do I need an internet connection? You need one while a research job is running, because the research agents fetch public web sources. Reading existing profiles, scores, and people works fully offline.
What does it cost to run? Augur OS itself is free and open source under Apache 2.0. The research engine runs through the Claude CLI, so you pay for that usage under your own API access.
Can I customize what the research looks for? Yes. The prompt templates that drive research and scoring are part of the project, and you define your scoring rubric in the app to match your ideal customer.
How accurate is the research? Research agents are instructed to attach evidence sources, and the bounded verifier rejects or weakens claims whose supplied metadata is inadequate. It does not independently fetch every URL. Profiles surface citations and unresolved claims so you can inspect material evidence yourself.
Which platforms are supported? Augur OS builds as a native desktop app via Tauri 2. It can be built for macOS, Windows, and Linux, subject to the Tauri platform prerequisites.
Contributions are welcome. Bug reports, feature requests, and pull requests all help. For anything large, open an issue first so we can agree on the approach. Every pull request is reviewed by a maintainer before merge.
Start with CONTRIBUTING.md for local setup, branching, and commit conventions.
Found a vulnerability? Please report it privately. See SECURITY.md.
Augur OS is released under the Apache License 2.0. Copyright 10XU Inc.
Augur reads the signals. You close the deal.
Built by Divyam Talwar at 10XU Inc.