How do I sign up for Galileo Free and start sending traces from our LLM app?

Most teams don’t discover critical LLM failures until users complain or an agent takes a bad action. The fastest way to get ahead of that is to instrument your app and start streaming traces into Galileo—without waiting on a sales call or a long procurement cycle.

This guide walks through how to sign up for Galileo Free and start sending traces from your LLM app so you can see real behavior, spot failure modes, and lay the groundwork for evals and guardrails.

Quick Answer: Create a free Galileo account, grab your workspace API key, install the Galileo SDK (or use an observability integration), and wrap your LLM and tool calls so sessions, traces, and spans are automatically sent to Galileo in real time.

---

The Quick Overview

• What It Is: Galileo Free is the no-cost tier of Galileo’s AI reliability platform that lets you capture traces from your LLM app, inspect failures, and get a feel for evals and guardrails—without a contract or demo call.
• Who It Is For: Builders shipping LLM apps, RAG systems, or agents who want production-grade observability and evaluation but need to start quickly and prove value before scaling.
• Core Problem Solved: You can’t improve reliability when you’re flying blind. Galileo Free gives you an immediate view into live traffic—sessions → traces → spans—so you can see hallucinations, bad tool calls, and drift as they happen.

---

How It Works

At a high level, the flow looks like this:

1. Sign up and create a workspace
   You register for Galileo Free, verify your email, and create or join a workspace. This workspace holds your traces, evals, and guardrail policies.

2. Generate an API key and install the SDK
   From the Galileo UI, you create a workspace API key. In your app, you install the Galileo SDK (or an integration like LangChain / LlamaIndex / custom middleware) and configure it with that key.

3. Instrument your LLM calls and send traces
   You wrap your LLM calls, RAG retrieval steps, and agent tool actions so each request generates a structured trace. Galileo ingests those traces, surfaces failure patterns, and sets you up to add evaluations and guardrails later—without changing your core app logic.

Step 1: Sign up for Galileo Free

You don’t need a sales call to get in.

1. Go to https://galileo.ai.
2. Click Get Started for Free or Sign Up.
3. Sign up with:
   • Your work email (recommended for team workspaces), or
   • SSO if your org has it enabled.
4. Confirm your email if prompted.

Once you complete sign-up, you’ll land in the Galileo app and either:

• Join an existing workspace (if your org already has one), or
• Create a new workspace for your LLM/agent project.

If you’re experimenting on your own, create a dedicated workspace so you can keep traces for this app separate from other teams and environments.

Step 2: Understand the Galileo Free tier

Galileo Free is designed to get you from “zero” to “live traces” in minutes and give you enough volume to debug real behavior.

At a high level, you can:

• Send a meaningful number of traces each month (e.g., early-stage or staging traffic).
• Inspect sessions, traces, and spans for your LLM app or agent.
• Start designing evaluation criteria that later become guardrails in production.

When you’re ready for 100% traffic coverage, custom evaluators, and real-time protection (Protect) with sub-200ms guardrails, you can upgrade. But you don’t need that to start sending traces and learning.

---

Step 3: Create your workspace API key

To let your app talk to Galileo, you’ll use a workspace-level API key.

1. In the Galileo app, open the Settings or Workspace Settings area.
2. Navigate to API Keys (or similar credentials section).
3. Click Create API Key.
4. Give it a name like staging-llm-app or agent-service-dev.
5. Copy the key and store it securely (e.g., as an environment variable, not in source control).

You’ll reference this key in your app configuration:

export GALILEO_API_KEY="your_workspace_api_key_here"

If your team uses multiple environments (dev/staging/prod), create separate keys per environment so you can segment traffic and revoke access cleanly if needed.

---

Step 4: Install the Galileo SDK (or integration)

You can integrate Galileo with your LLM app using:

• A language-specific SDK (e.g., a Python or Node package), or
• A framework integration (e.g., LangChain, LlamaIndex, or your own tracing middleware).

Below is a representative Python example; adapt to your stack.

Example: Python SDK installation

pip install galileo-ai

Then initialize the client:

from galileo import GalileoClient

client = GalileoClient(api_key=os.environ["GALILEO_API_KEY"])

If you’re running in Node/TypeScript, the pattern is the same: install the package, import the client, and configure it with your API key.

---

Step 5: Instrument your LLM app to send traces

When we talk about “sending traces,” we’re not just talking about dumping logs. Galileo expects structured telemetry:

• Session – A full user interaction or agent run (e.g., one support case or one research task).
• Trace – A single “run” within that session (e.g., a user question answered by a RAG pipeline).
• Span – Individual steps inside the trace (LLM calls, retrieval, tool actions, post-processing).

The more you align with this structure, the better Galileo can help you debug and later apply evals and guardrails.

Basic pattern: wrap a single LLM call

For a simple LLM-backed endpoint, you might:

1. Start a trace when a request comes in.
2. Attach the user input and context.
3. Log the LLM completion as a span.
4. End the trace and send it to Galileo.

Conceptually:

trace = client.start_trace(
    name="support_question",
    metadata={"user_id": user_id, "environment": "staging"}
)

# Log the input as a span
trace.log_span(
    name="user_message",
    kind="input",
    data={"prompt": user_prompt}
)

# Your existing LLM call
llm_output = call_llm(user_prompt)

# Log the LLM call
trace.log_span(
    name="llm_completion",
    kind="llm",
    data={
        "model": "gpt-4.1",
        "prompt": user_prompt,
        "completion": llm_output
    }
)

trace.end()  # sends to Galileo

This gives you immediate visibility into:

• What the user asked,
• What prompt went to the model, and
• What came back—per request.

Richer example: RAG or agent with tools

For an agent that uses tools (e.g., search, database, pricing API), you’ll want each tool call to show up as its own span so you can debug wrong tool selection or bad parameters.

Example structure:

trace = client.start_trace(
    name="agent_research_session",
    metadata={"user_id": user_id, "environment": "dev"}
)

trace.log_span(
    name="user_message",
    kind="input",
    data={"prompt": user_prompt}
)

# Tool selection span
trace.log_span(
    name="tool_selection",
    kind="decision",
    data={"chosen_tool": "web_search", "reason": "user asked about latest news"}
)

search_results = web_search(user_prompt)

trace.log_span(
    name="web_search_call",
    kind="tool",
    data={"query": user_prompt, "results_count": len(search_results)}
)

answer = call_llm(compose_prompt(user_prompt, search_results))

trace.log_span(
    name="final_answer",
    kind="llm",
    data={"completion": answer}
)

trace.end()

In Galileo, this will show as a timeline of spans inside a trace, so you can see:

• When your agent picked the wrong tool,
• When retrieval returned garbage,
• When the LLM hallucinated over incomplete context.

That’s the raw material for evaluation and guardrails.

---

Step 6: Verify traces in Galileo

Once you deploy your instrumentation:

1. Generate a few test requests through your app.
2. In the Galileo UI, navigate to the Traces view.
3. Filter by:
   • Workspace (your app workspace),
   • Environment (e.g., dev or staging metadata),
   • Trace name (e.g., support_question, agent_research_session).

You should see:

• A list of traces with timestamps and durations.
• For each trace, a tree or timeline of spans (input, LLM calls, tools).
• Raw payloads for each span (prompts, completions, tool parameters/results).

If you don’t see traces:

• Double-check the API key and environment variable.
• Confirm your app can reach Galileo’s API endpoint from your network.
• Verify that trace.end() (or the equivalent in your SDK) is actually being called.

---

From traces to reliability: what you can do next

Getting traces into Galileo Free is step one. From there, you can start transitioning from “observability-only” to “evals and guardrails”:

• Design evaluations
  Use the traces you’re collecting to define what “good” looks like: no PII leaks, grounded RAG answers, correct tool usage, safe tone. Later, Galileo’s Evaluation Engine and Luna-2 models can run these evaluators continuously.

• Catch unknown unknowns with Signals (on upgrade)
  At scale, you won’t know every failure pattern upfront. Signals analyzes 100% of your traces to surface anomalies—like new prompt injection patterns or sudden drift—and can turn those into evaluators.

• Protect production traffic (on upgrade)
  When you’re ready for real-time guardrails, Protect intercepts every input/output, scores them against your evaluator-backed metrics, and triggers actions like block, redact, override, or webhook—usually in under 200ms.

The important part right now: by sending traces from day one, you’re building the telemetry and test sets that later become your evaluation assets and production guardrails.

---

Common questions about Galileo Free and tracing

Do I need to talk to sales to use Galileo Free?

Short Answer: No. You can sign up and start sending traces without a demo or sales call.

Details: Galileo Free is designed for developers to self-serve. Go to the site, create an account, create your workspace, generate an API key, and you’re ready to integrate. When you outgrow the free tier—e.g., you need 100% traffic coverage, custom evaluators, or enterprise deployment (VPC/on-prem)—you can contact sales to discuss an upgrade, but it’s not required to get started.

What’s the best environment to start sending traces from?

Short Answer: Start with dev or staging, then roll into production once you’re comfortable.

Details: For most teams:

1. Dev: Wire up tracing in your dev environment first so you can iterate on span structure and metadata without impacting real users.
2. Staging: Once your instrumentation is stable, send a higher volume of staged traffic and ensure Galileo handles your real payload shapes, tool calls, and access patterns.
3. Production (on upgrade): With guardrails in place and latency budgets met, you can use Galileo to cover 100% of production traffic—so you catch failures after the first bad signal, not after thousands of user-visible issues.

---

Summary

To stop flying blind with your LLM app, you need traces—sessions, traces, and spans that reflect real behavior in real time. Galileo Free lets you sign up in minutes, generate an API key, and instrument your LLM, RAG, or agent system so every request becomes a structured trace you can inspect and later evaluate.

Once traces are flowing, you’re not just “monitoring” your app; you’re building the foundation for evals, Signals-driven detection, and Protect guardrails that can block hallucinations, prevent prompt injections, and keep PII from leaking—without bolting on heavyweight LLM judges or brittle feature flags.

---

Next Step

Get Started