When normal software fails, you get stack traces, database logs, and error lines. But when an AI agent hallucinates, stalls for 10 seconds, or burns through \$50 in tokens, it’s an opaque black box.
Feenion gives you complete X-ray vision into every prompt, retrieval chunk, tool call, and token dollar — 100% locally on your machine.
Modern AI apps aren't single API calls — they are complex distributed systems of prompts, vector databases, and multi-step tool reasoning.
When an agent gives a bad answer, you don't know whether the user query was misunderstood, the vector database retrieved irrelevant docs, or the LLM failed to synthesize the answer.
A single multi-turn agent loop can silently make 12 LLM calls, taking 18 seconds and costing \$0.40 per request. Without tracing, you cannot identify which step is the bottleneck.
Sending sensitive user prompts, private enterprise knowledge base chunks, and customer conversations to external cloud observability platforms creates compliance and security risks.
Feenion reconstructs the entire execution causality tree so you can inspect inputs, outputs, tokens, latency, and costs for each component.
No heavy cloud infrastructure. Feenion runs as a single lightweight container and a Python library.
Spins up the telemetry ingestion server and React UI with embedded SQLite WAL storage on localhost:8000.
Install the zero-overhead client into your Python AI backend or agent framework.
from openai import OpenAI
from feenion.integrations.openai import instrument_openai
client = OpenAI()
instrument_openai(client)
# Automatically captures tokens, latency, cost, and trace context:
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Explain Raft Consensus Algorithm."}]
)from google import genai
from feenion.integrations.gemini import instrument_gemini
client = genai.Client()
instrument_gemini(client)
response = client.models.generate_content(
model="gemini-2.0-flash",
contents="Explain vector embeddings in machine learning."
)from anthropic import Anthropic
from feenion.integrations.anthropic import instrument_anthropic
client = Anthropic()
instrument_anthropic(client)
response = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1024,
messages=[{"role": "user", "content": "Analyze system architecture."}]
)from langchain_openai import ChatOpenAI
from feenion.integrations.langchain import FeenionCallbackHandler
handler = FeenionCallbackHandler()
llm = ChatOpenAI(model="gpt-4o", callbacks=[handler])
chain = prompt | llm
chain.invoke({"topic": "Observability"}, config={"callbacks": [handler]})from feenion import trace, span
@trace(name="rag_query_pipeline", span_type="agent")
def search_and_answer(query: str):
with span("chroma_vector_search", span_type="retrieval", input={"q": query}):
docs = vector_db.query(query, top_k=5)
with span("synthesize_response", span_type="llm"):
return generate_answer(query, docs)Everything needed to inspect, benchmark, and debug AI workloads.
Instantly identify slow vector lookups and model latencies along the critical path.
Visualize complex parent-child causality graphs across agents, tools, and retrievers.
Dynamic pricing registry calculates exact token expenditures per model and workspace.
Run forever on your own hardware without per-seat pricing or cloud vendor lock-in.