slorg vs. Perplexity
Both produce an answer plus ranked sources. One is a hosted product with a polished UI; the other is six functions you can read. They overlap on shape and disagree on almost everything else.
The shape of the comparison
Perplexity is a closed-source, hosted answer engine. The system prompt, model selection, retrieval backends, and ranking logic are all internal. From the user's point of view: type a question, get an answer with footnoted citations. From the developer's point of view: an API key, a JSON endpoint, no visibility into the planning.
slorg is an open-source npm package (lorg) that runs a fixed six-step pipeline:
draft answer, knowledge graph, keyword extraction, SearxNG multi-engine search, content fetch,
relevance scoring. Documented end-to-end in the README. Self-hosted by definition.
The interesting questions are not "which has a nicer answer" (both can produce good answers for easy queries) but: who owns the editorial layer, who knows the failure modes, and what does the result object look like.
Side-by-side
| Dimension | slorg | Perplexity |
|---|---|---|
| Deployment model | Self-hosted. Node 18+, npm install, OpenAI-compatible API key. Docs at docs.skelfresearch.com/slorg. | Hosted product. Sign up at perplexity.ai or call the public API. No self-hosting option. |
| Source visibility | MIT. Source on GitHub. The full pipeline (six steps) is documented in the README. | Closed source. The system prompt and ranking logic are not public. |
| Search backends | SearxNG against Google, Bing, Yahoo, DuckDuckGo by default; configurable via LORG_SEARCH_ENGINES. | Not publicly documented. Multiple backends are implied but the list and the mix are not disclosed. |
| Model | OpenAI-compatible. Default gpt-4o-mini; configurable to any compatible endpoint via OPENAI_BASE_URL. | Perplexity's own models (Sonar family) plus optional frontier model selection on paid tiers. Not bring-your-own. |
| Planning step | Explicit: step 1 drafts an answer, step 2 builds a knowledge graph, step 3 extracts keywords from the graph. All three artifacts are returned in the response. | Implicit. Whatever planning happens is internal; the user sees the final answer and citations only. |
| Per-result scoring | Yes. Step 6 scores each result 0–1 against the original query. The score is a field on each result. | Implicit in citation selection. The score itself is not surfaced. |
| Latency | Slow by design. ~5–15 s wall-clock for default config (three LLM calls + content fetch + scoring). No streaming. | Sub-second to a few seconds, with streaming output. Optimized for interactive use. |
| Response shape | JSON object with answer (draft), knowledgeGraph, keywords, results[] (each with title, source, score, content), and tokenCount. | Answer text with inline citation markers, plus a list of source URLs. Polished for display. |
| Cost model | You pay your OpenAI bill plus your hosting bill. Token usage is returned per query for accounting. | Free tier with daily limits; paid tiers; API priced per query/token. No model-cost passthrough. |
| License | MIT. Use it however. | Proprietary product. Terms of service apply. |
Where each is the right tool
Perplexity wins when
- You want a fast, polished answer for a one-off question and don't need to know how it was assembled.
- You don't want to run infrastructure or pay an OpenAI bill.
- You want a hosted UI rather than building one yourself.
- Sub-second perceived latency matters for your use case.
slorg wins when
- You need to see the plan: the draft answer, the graph, the extracted keywords.
- You're building a research workflow that consumes the intermediate artifacts, not just the final answer.
- You want to point retrieval at a specific subset of search engines (or eventually, your own SearxNG instance against private indexes).
- You need to swap the model — to a local llama.cpp endpoint, to a cheaper provider, to a stronger frontier model — without changing tools.
- You'd rather pay your own OpenAI bill than a vendor markup.
What this comparison does not claim
Perplexity is a sophisticated product with engineering investment that an open-source side project does not match in every dimension. Its hosted UI is better than anything slorg ships. Its latency is better than slorg's by an order of magnitude on most queries. Its model and retrieval choices are likely well-tuned across a much larger query distribution than ours.
What slorg offers is not "better answers." It is visibility. The full pipeline is six functions you can read; the response is a structured object that exposes every intermediate artifact; the model and backends are your choice. If those properties matter to you, you have a real reason to pick slorg. If they don't, Perplexity is probably the right call.
Background reading
- Most agentic search throws queries at Google and prays — on the dominant wrapper pattern and what plan-first search trades for.
- Source-aware retrieval: knowing what your engine knows — on the result-object visibility argument in detail.
- slorg architecture — the canonical reference for what the pipeline actually does.