You can easily trace any function using the unify.traced decorator. 
import unify

@unify.traced
def my_function(a, b):
    return a + b

my_function(1, 2)
If you create a view tile and select the trace in the table, you’ll then see the trace viewer.
Traces are made up of spans, each of which represent a unit of computation. Traces can have an arbitrary number of spans, and spans can have child spans up to an arbitrary depth. 
import unify

@unify.traced
def inner_fn(a, b):
    return a + b

@unify.traced
def mid_fn(a, b):
    c = inner_fn(a, b)
    d = inner_fn(c, b)
    return c * d

@unify.traced
def outer_fn(a, b):
    c = mid_fn(a, b)
    d = mid_fn(c, a)
    return d / c

outer_fn(3, 4)
In the trace view pane, this will look as follows:

​
LLM Traces

LLMs can also be traced, by setting traced=True in the client constructor (see Universal API section). 
import unify

client = unify.Unify("o3-mini@openai", traced=True)
client.generate("Hello, world!")
When these LLM calls are part of a broader trace, then the cost and tokens are accumulated in the trace, propogating the cost and tokens to the parent spans. 
import unify

@unify.traced
def llm_jury(question):
    a1 = unify.Unify("o3-mini@openai", traced=True).generate(question)
    a2 = unify.Unify("deepseek-r1@together-ai", traced=True).generate(question)
    return unify.Unify("gpt-4o@openai", traced=True).generate(f"Summarize the following: {a1} {a2}")

llm_jury("What is the capital of France?")