There's a moment every AI engineering team hits — usually somewhere between their third production incident and their first compliance audit — when they realise the tools they're using weren't designed for this.
Not the models. The models are extraordinary. The problem is everything around them.
The way prompts are stored. The way calls go untraced. The way PII slips through with no one watching. The way an auditor walks in and asks a question no one on the team can answer.
We built GetStackLens because we hit all of those walls ourselves. And when we looked for a single platform that solved them together, we couldn't find one.
So we built it.
The Three Walls
These aren't theoretical problems. They're the three things that quietly break AI teams — not at once, but gradually, until they become expensive.
Wall 1: Prompt Chaos
When a team starts building with LLMs, prompts live wherever they fit. .env files. Hardcoded strings. Notion docs. Slack threads. The first few weeks are fine.
Then the system grows. The team grows. And suddenly no one knows which prompt is running in production, who changed it last, or what it looked like before the regression. You roll back the code — but the prompt was never versioned. The incident drags on.
Prompt management sounds like a minor problem until it isn't. Then it's a 3am incident.
Wall 2: Blind LLM Usage
You can instrument everything about your infrastructure — CPU, memory, latency percentiles, error rates — and still have no idea what's happening inside your LLM calls.
Which model was actually used? What did the request cost? Where did latency spike? Why did that response degrade in quality? Was it the model, the prompt, the context, or the retrieval step?
Most teams are debugging by intuition. Running in production without observability isn't a technical choice — it's a constraint. The tooling to fix it hasn't been accessible enough.
Wall 3: Compliance Risk
This wall is arriving fast, and most teams aren't ready.
The EU AI Act's transparency and documentation obligations come into force in August 2026. If your system uses LLMs to make or influence decisions that affect people — and if you're operating in or selling into the EU — you need to be able to answer specific questions:
Which models touched customer data? When? What did they receive and return? Are you logging it? Can you produce a compliance report?
And beyond regulation: even without an audit, customer PII flowing through LLM requests with no detection, no guardrails, and no audit trail is a liability your team is quietly accumulating.
Why One Platform
We could have built three separate tools — one for each wall. Many teams have tried patching together separate products. It doesn't work.
The reason is that these problems share data. The prompt version that ran at a given timestamp is part of the compliance record. The PII detected at the HTTP layer needs to be correlated with the trace for that specific request. The A/B test for prompt variant B needs to show quality score distribution across 10,000 calls.
When your prompt versioning, tracing, and governance live in separate tools, that correlation is impossible. You end up with three dashboards and no answers.
GetStackLens is one data model. One platform. Three products that talk to each other.
The Three Products
FlowOps — Prompt Operations
FlowOps treats prompts the way engineering teams treat code.
Every prompt is versioned. You have separate environments — development, staging, production — with promotion gates and approval workflows. You can run A/B tests across prompt variants and measure quality scores across production traffic before committing to a change.
No more prompts living in Notion. No more "who changed this and when?". No more 3am rollbacks with no rollback path.
StackTrace — LLM Observability
StackTrace gives you full visibility into every LLM call, agent execution, and RAG pipeline step.
For each request, you see: the model used, the token counts, the cost, the latency, the semantic quality score, the prompt version that ran, and the full input/output. You can drill into any request in seconds. You can aggregate across models, prompts, and time windows.
The Python SDK is ready. You instrument your code in a few lines, and everything flows into StackTrace automatically.
import getstacklens
getstacklens.init(api_key="your-api-key")
# Your existing OpenAI calls are traced automatically
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}]
)TypeScript and .NET SDKs are in development.
GovernAI — Policy and Compliance
GovernAI operates at the HTTP layer — before requests leave your infrastructure.
PII detection runs on every request body and response, catching names, emails, phone numbers, card numbers, and custom patterns before they reach external model APIs. Policy rules are defined as code, versioned alongside your prompts.
When an auditor asks for your EU AI Act Article 13 documentation, GovernAI generates it in one click.
Who This Is For
GetStackLens is built for engineering teams shipping AI systems in production — especially teams in regulated industries where the cost of getting it wrong is high.
If you're building with OpenAI, Anthropic, Gemini, Azure OpenAI, AWS Bedrock, LangChain, LlamaIndex, AutoGen, or CrewAI — GetStackLens works with your existing stack. No rip-and-replace.
If you're a .NET shop: we're building the .NET SDK alongside Python. Enterprise AI teams running on Microsoft infrastructure are an underserved market, and we're fixing that.
If you need to self-host: GetStackLens runs on a single $20/month VPS with Docker Compose. Your data never leaves your infrastructure. The core is open.
Where We Are Today
We're in early access. Here's what that actually means:
What's ready: The Python SDK is production-ready with full sync and async support. The docs cover all three products, the Python SDK, and the full architecture — so you can read exactly how everything fits together before it's in your hands.
What's still coming: The platform itself — both the cloud-hosted version and self-hosting — is in active development. TypeScript and .NET SDKs are in progress alongside it. We'll announce access and pricing when the platform launches.
We're opening the waitlist now so we onboard the right teams first — the ones who'll push it hardest and give us the feedback that matters.
Get Early Access
If your team is shipping AI in production, join the waitlist. Early access is invite-based — we're onboarding teams in small batches as the platform rolls out.
The docs are live — you can read through the full architecture, the SDK, and all three products right now.
And if you want to follow along as we build — the announcements, the technical posts, the EU AI Act breakdowns — this blog is where we'll publish them.
We're early. We're building. And we're glad you're here.
GetStackLens is open core. The Python SDK is on PyPI. Platform access — self-hosted and cloud — is coming. Pricing will be announced at launch.