AgentOps observability
Trace every agent run as a step tree, inspect prompts and tool calls, replay failures, and roll token cost into one view.
Agent infrastructure for production systems
Romanica
The runtime and operations layer for autonomous AI agents. Observe every step, orchestrate durable workflows, share memory, route models, scale workers, govern actions, and keep humans in control.
10
infrastructure layers
5
agent-native span types
2
surface and engine languages
0
infra migrations to start tracing
What Romanica does
One control plane for agents that behave like distributed systems.
Teams should not have to stitch together tracing, queues, memory, routing, approvals, policy, and dashboards before an agent can run in production. Romanica packages those operating primitives together.
Runtime and workflows
Queue long-running work, persist execution attempts, compile agent DAGs, and keep lifecycle state visible from request to completion.
Memory and coordination
Store scoped memories, rank retrieval by confidence and freshness, and move JSON messages between agents through project channels.
Control plane for production
Route model calls, watch worker pressure, evaluate policies, create approvals, and turn traces into regression cases.
Product surface
From a wall of logs to an execution timeline.
Romanica starts with the sharpest production pain: an agent failed, looped, retried, or burned tokens and no one can see why. The dashboard turns each run into a navigable tree with cost, latency, input, output, and failure context attached to every step.
Prompt and response inspection
Tool call args and returns
Token and dollar rollups
Replay-ready failure records
TracesRuntimeWorkflowsMemoryRoutingGovernance
support-agent.run
retrievalsearch-kb42 msok
llmdraft-response1.8 sretry
toolcreate-ticket360 msok
approvalrefund-policywaitinghold
Selected span
draft-response
modelgpt-4o
cost$0.042
statusretry
{
"tool_calls": 2,
"prompt_tokens": 1248,
"completion_tokens": 318,
"retry_reason": "policy_blocked_tool"
}The ten layers
Built around the full operating model for autonomous agents.
The current product center is AgentOps and observability. The same local platform already exposes real paths across the broader control plane, so trace data can feed routing, evaluation, approvals, and runtime decisions.
Agent Runtime
Isolated agents, queued runs, persisted HTTP execution attempts.
Workflow Orchestration
Versioned DAGs, Rust compilation, dispatch lifecycle records.
State and Memory
Scoped records with ranked retrieval, lineage, confidence, and freshness.
AgentOps Observability
Structured traces, span trees, replay, cost rollups, and analytics.
Dynamic Model Routing
Observed model candidates selected by cost, latency, and health.
Scaling Infrastructure
Worker pool pressure, autoscaling recommendations, and applied decisions.
Agent Communication
Project-scoped message bus for handoffs, acknowledgements, and failures.
Security and Governance
API scopes, policy decisions, immutable audit events, and route families.
Evaluation Infrastructure
Trace-derived failure signals and exportable LLM regression cases.
Human Collaboration
Approval checkpoints, decisions, intervention records, and review queues.
For developers
Instrument your agent without moving your stack.
Romanica fits the TypeScript agent ecosystem: Vercel AI SDK, LangChain.js, Next.js, custom tool loops, and raw model API calls. The SDK emits spans asynchronously, batches exports, and fails silently if the backend is unavailable.
Auto-nested spans
Batched async export
Large payload offload
OpenTelemetry-shaped data
agent.ts
import { Romanica } from "@romanica/sdk";
const romanica = new Romanica({
apiKey: process.env.ROMANICA_API_KEY
});
await romanica.trace("support-agent", async (trace) => {
await trace.span("retrieval", "search-kb", async (span) => {
span.setRetrieval({ query: "refund policy", topK: 3 });
span.setOutput(await searchKB("refund policy"));
});
await trace.span("llm", "draft-reply", async (span) => {
const response = await model.generate(messages);
span.setLLM({ model: "gpt-4o", usage: response.usage });
span.setOutput(response);
});
});Operational signals
Trace data becomes the nervous system for the rest of the platform.
trace.ingested
94.8k spans
Every LLM, tool, retrieval, and custom span lands in one tree.
routing.selected
31% lower cost
Model choices use observed latency, spend, and health constraints.
policy.allowed
12.4ms p95
Planned actions are checked before tools mutate production state.
approval.waiting
7 checkpoints
Humans can approve, reject, or cancel high-risk workflow steps.
Architecture
TypeScript where teams touch it. Rust where throughput matters.
Surface layer
SDK, API gateway, dashboard, and shared schemas live in TypeScript so adoption is natural for teams already building with TS agent stacks.
Engine layer
Rust engines handle the hot paths: trace ingest, workflow DAG compilation, and eventually sandboxed runtime execution.
Storage layer
Postgres stores trace and control-plane metadata. S3-compatible object storage keeps large inputs and outputs out of relational hot paths.
Governance layer
Scoped API keys, policy checks, immutable audit events, and approval records give enterprise teams room to operate safely.
Romanica cloud
Build agents that can be observed, governed, routed, recovered, and improved.
Romanica is for teams moving from demos to durable AI operations. Start with tracing, then let the same execution data power the rest of the agent control plane.