Strix — Agentic Framework & Deterministic vs. LLM-Driven Tooling
Technical audience, but written to be checkable by anyone: every claim below was
verified with a direct search of the source (grep), not inferred from the
project's marketing copy.
Strix does not use LangChain, LangGraph, CrewAI, or AutoGen
A repo-wide search (grep -rniE "langchain|langgraph|crewai|autogen" across every
.py, .toml, and .md file) turns up exactly one match, and it is not a
dependency: strix/skills/vulnerabilities/llm_prompt_injection.md — an internal
knowledge-pack file that briefs Strix's own agents on how to test a target
application for prompt-injection weaknesses, and mentions LangChain/LangGraph as
examples of frameworks a target might be built with. It is content about what
Strix can attack, not infrastructure Strix runs on.
Strix's actual dependency (pyproject.toml, [project] dependencies):
"openai-agents[litellm]>=0.19.0,<0.20",
"openai>=2.45.0,<3",
"litellm",
The OpenAI Agents SDK, with the LiteLLM extra enabled, is the entire agentic
runtime. litellm (also listed directly) is what lets STRIX_LLM accept
provider-prefixed model ids from OpenAI, Anthropic, Bedrock, Vertex, OpenRouter,
and self-hosted endpoints, without Strix needing a separate adapter per provider.
There is no separate graph-orchestration library (no LangGraph, no CrewAI) —
Strix's own strix/core/agents.py (AgentCoordinator) is the orchestration layer,
built directly on top of the SDK's single-agent primitives. See
STRIX — Backends and HLD.md's "Third-party agent runtime" section for the
full breakdown of what the SDK provides vs. what Strix built itself.
Why this matters for a reader coming from LangGraph/CrewAI
If you're familiar with LangGraph's explicit state-graph nodes/edges or CrewAI's
Crew/Task/Process abstractions, the closest analogue in Strix is:
| LangGraph/CrewAI concept | Strix equivalent | Where |
|---|---|---|
| Graph nodes / Crew agents | SandboxAgent instances (root + children) |
strix/agents/factory.py |
| Graph edges / task handoffs | Mailbox messages via AgentCoordinator.send() — not a static graph; the tree shape is decided at runtime by which agents call create_agent |
strix/core/agents.py, strix/tools/agents_graph/tools.py |
| Checkpointing / persistence | Coordinator state snapshotted to agents.json; per-agent conversation state in a SQLite session (agents.db) |
strix/core/agents.py: _maybe_snapshot(), strix/core/sessions.py |
| Tool nodes | Every entry in _BASE_TOOLS (strix/agents/factory.py) plus SDK-native Shell/Filesystem capabilities |
strix/tools/ |
| A supervisor/router node | The root agent, enforced by its system prompt (not a separate framework construct) | strix/agents/prompts/system_prompt.jinja |
The key structural difference: Strix's agent tree is not a predefined graph you author ahead of time (as in LangGraph). It's dynamically grown at runtime — the root agent decides how many specialists to spawn and what to name them, based on what it finds in the target, and the tree shape is only known after the scan finishes.
Deterministic vs. LLM-driven, module by module
This expands the four-question discipline used throughout docs/modules/*.md into
one consolidated table, so "where is the AI, exactly" can be answered in one place.
| Module | Deterministic (no model call) | LLM-driven |
|---|---|---|
strix/interface |
Argument parsing, Docker preflight, run-directory naming, diff-scope computation, reading finished-run artifacts for the viewer | warm_up_llm() performs a connectivity check only — no reasoning |
strix/core |
Coordinator state snapshotting/resume, mailbox routing, budget/turn-limit enforcement (hooks.py), lifecycle-tool stop-condition checking |
None directly — run_agent_loop() drives the SDK's Runner, which is where the model actually reasons and calls tools |
strix/agents |
Tool-list assembly, skill-markdown loading, Jinja template rendering | None directly — this module prepares the prompt; the model reasoning happens once the agent runs |
strix/tools |
CVSS metric validation/scoring math, output truncation/spilling, todo/notes CRUD persistence, mailbox message formatting, all SDK-native Shell/Filesystem execution |
web_search (Perplexity-backed) is the one tool that itself calls an external model API |
strix/runtime |
100% — container lifecycle, manifest/mount construction, resource limits, Caido guest-login retry loop | None |
strix/report |
CVSS score/severity arithmetic once metrics are supplied, vuln-NNNN ID assignment, Markdown/CSV/JSON/SARIF rendering, dependency/CVE-finding dedup (identity-based) |
report/dedupe.py: check_duplicate() — an explicit LLM-judge call for non-dependency findings, optionally on a distinct model (STRIX_DEDUPE_MODEL) |
strix/config |
Settings precedence resolution, provider-quirk predicate functions | None — this module decides how a model gets called, it doesn't call one |
strix/skills |
100% — static Markdown content, file lookup only | None |
| Every actual testing decision (what to probe, which payload, when a finding is real) | — | Entirely the agent (root + children), via the SDK's Runner.run_streamed() turn loop |
The pattern that holds everywhere: infrastructure, bookkeeping, and arithmetic are deterministic; judgment calls are LLM-driven, and the one deliberate exception (dedup) is called out explicitly rather than left ambiguous.
Related: STRIX — Backends, STRIX — Architecture (HLD), HLD.md, LLD.md.