The demo fixture

The demo button on the homepage does not scan a GitHub repository. It scans this file: a small, deterministic CrewAI example that ships inside the AxiomGate repository as a golden test fixture. It is published here so that the demo result can be checked against its own subject.

Subject identifier: axiomgate-fixture:crewai-demo

Path in the AxiomGate repository: tests/v1/golden/crewai_demo/agents.py

Content hash (SHA-256 of the file below):
99682b16955a3db96767e7ad6aa41d623e906537224862a6d3793ea6518e0ed9

Relationship to the scanner: src/ui/preview_scan.py runs the same analysis pipeline over this path that it runs over a downloaded public repository. The demo takes no separate code path through the analyzer and receives no fixture-specific tuning.

The source, verbatim

"""CrewAI multi-agent delegation with tool capabilities demo.

Demonstrates:
  1. Multi-agent delegation chain: researcher -> analyst -> writer
  2. Concrete tool capabilities: web_search on researcher, code_interpreter on analyst
  3. Static governance analysis: unattenuated delegation and privilege amplification boundaries
"""
from crewai import Agent, Task, Crew
from langchain_openai import ChatOpenAI
from crewai.tools import tool


@tool
def web_search(query: str) -> str:
    """Search web resources and technical documentation."""
    return "search results"


@tool
def code_interpreter(code: str) -> str:
    """Execute Python code for quantitative data analysis."""
    return "execution output"


# Define agents with delegation and tool capabilities
researcher = Agent(
    role="researcher",
    goal="Gather security research and intelligence",
    backstory="Senior research specialist.",
    llm=ChatOpenAI(model="gpt-4o"),
    allow_delegation=True,
    tools=[web_search],
)

analyst = Agent(
    role="analyst",
    goal="Analyze evidence and execute analytical models",
    backstory="Lead data & risk analyst.",
    llm=ChatOpenAI(model="gpt-4o"),
    allow_delegation=True,
    tools=[code_interpreter],
)

writer = Agent(
    role="writer",
    goal="Compile executive risk findings into deliverables",
    backstory="Technical communications architect.",
    llm=ChatOpenAI(model="gpt-4o"),
    allow_delegation=False,
)

# Tasks with explicit assignments
research_task = Task(
    description="Research attack surface and boundary definitions",
    agent=researcher,
    expected_output="Research dossier",
)

analysis_task = Task(
    description="Model delegation paths and evaluate capability amplification",
    agent=analyst,
    expected_output="Analysis matrix",
)

writing_task = Task(
    description="Author security brief and remediation roadmap",
    agent=writer,
    expected_output="Executive report",
)

crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[research_task, analysis_task, writing_task],
)

# Explicit delegation edges
researcher.delegate(task="Analyze research dossier", recipient=analyst)
analyst.delegate(task="Format security findings", recipient=writer)

if __name__ == "__main__":
    crew.kickoff()

What this demonstrates

That the analysis is deterministic: the same bytes produce the same agents, tools, delegation edges and signals on every run.
That a tool name is not treated as evidence. This fixture declares a tool called code_interpreter, and the scan still reports code execution as NOT OBSERVED, because the resolved declaration body contains no execution sink.
That every reported signal carries a rule identifier, a rule version, a source location and an explicit statement of what it does not prove.

What this does not demonstrate

It does not show how the analyzer behaves on a large, dynamic or reflection-heavy codebase. This file is 81 lines long and was chosen to be small and stable.
It does not constitute general static taint or dataflow analysis. AxiomGate does not implement that, and no result here should be read as though it did.
It does not establish analyzer correctness in general. A passing fixture is one observation, not a proof.
It does not show runtime prevention. Nothing in this file is executed by AxiomGate at any point; the analysis is static.
An absent signal means not observed. It does not mean assessed as safe.

Why this file and not a public repository

A demo that names an external repository makes the demonstration depend on that repository staying reachable and unchanged. This fixture is versioned with the analyzer, so the subject of the demonstration cannot drift away from the claim made about it. For a scan of real third-party code, see the published browser-use teardown.