OllyGarden Onboarding: Better Observability and OpenTelemetry for Future Caribbean Builders

Future Caribbean hosted an onboarding session with Juraci Paixão Kröhling, CEO of OllyGarden, to help builders understand how better instrumentation can make their applications easier to monitor, debug, and improve.

Hosted by Lily Dash, the session focused on two OllyGarden resources available to builders: OllyGarden Insights and Rose, which analyze and improve application telemetry, and the OllyGarden OpenTelemetry Agent Skills, an open-source project designed to help AI coding agents generate better instrumentation from the start.

Juraci framed the session around a simple but important idea: if developers want to understand what their applications are actually doing in production, they need high-quality telemetry. That means properly implemented logs, metrics, and traces that can be sent to observability platforms such as Grafana, Datadog, Dash0, or other compatible systems.

Why instrumentation matters

Instrumentation gives developers visibility into how software behaves after it is deployed.

Logs can show what events occurred. Metrics can reveal system performance and trends. Traces can show how requests move through different services.

But simply generating telemetry is not enough. Poorly designed instrumentation can create too much noise, miss important context, expose sensitive information, or generate unnecessary observability costs.

Juraci explained that OllyGarden is designed to help developers evaluate whether their telemetry is actually useful and identify where their instrumentation could be improved.

For Future Caribbean teams building quickly during the buildathon, this can help avoid a common problem: creating an application that works during development but becomes difficult to understand once it is running in production.

OllyGarden Insights

The first part of the demo focused on OllyGarden Insights.

Once telemetry is sent to OllyGarden, the platform can analyze the data and provide developers with a summary of what their applications are producing.

Juraci demonstrated insights including:

• the number of spans being generated;
• log volume;
• metric data points;
• missing service-name attributes;
• trace cost drivers;
• log severity distribution;
• high-volume telemetry sources;
• frequently repeated log patterns.

For example, the platform can identify telemetry that is missing important OpenTelemetry resource attributes or highlight applications producing excessive debug logs in production.

This gives teams a clearer view into whether their telemetry is structured, useful, and cost-efficient.

Understanding where observability costs come from

Telemetry can become expensive when applications generate large volumes of logs or traces without a clear reason.

OllyGarden Insights helps developers identify the services or patterns responsible for the largest share of that volume. Juraci showed how the platform can highlight which services are consuming the largest portion of a team's trace budget and where most log records are being produced.

For teams scaling agentic applications, this matters because AI applications can produce substantial amounts of operational data across model calls, tools, workflows, APIs, and distributed services.

Better instrumentation can help teams preserve useful information without collecting unnecessary noise.

Meet Rose

The second major component of the session was Rose, OllyGarden's tool for reviewing and improving application instrumentation.

Rose can connect directly to a GitHub repository and analyze how the application is instrumented. Rather than simply reporting on telemetry after it has already been generated, Rose can inspect the actual code and identify places where instrumentation should be changed.

Juraci explained that Rose can:

• analyze existing instrumentation;
• identify telemetry problems;
• suggest improvements;
• flag potentially sensitive data;
• generate fixes;
• open pull requests with proposed changes.

That makes Rose useful both for applications that already have instrumentation and for teams trying to improve telemetry quality as the codebase evolves.

Catching personally identifiable information in logs

One of the clearest examples in the session involved personally identifiable information, or PII.

Developers sometimes accidentally log information such as names, email addresses, physical addresses, phone numbers, or complete user objects. That can become a serious issue when those logs are then transmitted to external observability systems.

Juraci demonstrated how Rose can review a repository and identify places where personal information may be leaking into application logs.

In one example, Rose identified code that was logging personal user data and generated a pull request that changed the instrumentation so the application logged only an opaque identifier rather than the entire object. The developer can then review the proposed change and decide whether to merge it.

For teams working in regulated industries or handling sensitive customer data, this type of automated review can be particularly valuable.

Human review stays in the loop

Rose is designed to help developers rather than silently modify their applications.

The tool identifies potential issues and surfaces them for a human to review. Once a developer agrees with the recommendation, Rose can generate a pull request containing the proposed fix.

That workflow gives builders the speed of automation while preserving human oversight over production code.

More than security

Although the PII example is important, Rose is not only a security tool.

Juraci explained that it can also help teams reason about the quantity and quality of instrumentation. In some places, an application may need additional instrumentation to make a workflow understandable. In other places, it may be collecting far too much data.

Rose is intended to help developers find that balance so the resulting telemetry remains useful for debugging and operations without producing unnecessary volume.

Builder access to OllyGarden

Future Caribbean builders have access to OllyGarden Insights and OllyGarden Rose.

Juraci explained that onboarding is primarily self-service rather than relying on individually distributed tokens or promo codes.

Builders can create an account through ollygarden.app, including signing up with a Google account. Once inside the platform, they can generate an API key and configure their OpenTelemetry collector to send telemetry to OllyGarden alongside their existing observability provider.

For Rose, builders can connect their GitHub repositories from the instrumentation section of the platform.

Enterprise access for Future Caribbean builders

Juraci also shared an additional benefit for Future Caribbean participants.

After connecting their GitHub application to OllyGarden, builders can ping Juraci in Discord, and the OllyGarden team can upgrade them to an Enterprise account.

Even without that upgrade, the standard account supports five repositories for free. This gives buildathon teams room to experiment with Rose across multiple repositories while also having a path to expanded access through the partnership.

OpenTelemetry Agent Skills

Juraci also introduced a separate open-source project called the OllyGarden OpenTelemetry Agent Skills.

These skills are designed for developers using AI coding agents such as Claude Code, Codex, and GitHub Copilot.

The idea is to provide coding agents with current, expert-level knowledge about how OpenTelemetry should be implemented. This matters because a general-purpose language model may know how to add instrumentation but still generate code based on outdated patterns.

OpenTelemetry evolves, and model training data may reflect practices that were common several years ago rather than the approaches developers should use today.

Give coding agents better OpenTelemetry knowledge

Juraci explained that without dedicated skills, a coding agent may eventually produce workable instrumentation, but it can require more prompting and more tokens.

OllyGarden maintains two related skill repositories. The OpenTelemetry Agent Skills focus on OpenTelemetry facts: what the platform supports and how the technology works. The broader OllyGarden Skills repository contains more opinionated guidance about how developers should accomplish specific tasks.

Juraci mentioned examples such as:

• configuring OpenTelemetry collectors on Kubernetes;
• validating collector configurations;
• decomposing OpenTelemetry Collector configuration files;
• integrating with OllyGarden.

This distinction lets developers combine authoritative technical knowledge with OllyGarden's recommended implementation patterns.

Using OllyGarden with AI coding agents

The two parts of OllyGarden's offering can support different stages of the development process.

While code is being created, the agent skills can help a coding assistant produce better instrumentation. Once that code is committed to GitHub, Rose can review the repository and identify instrumentation problems that remain.

Juraci summarized the relationship clearly: the skills can help while developers are creating code with coding agents, while Rose can help once the application code is already in GitHub.

That creates a useful feedback loop between building, reviewing, deploying, and observing an application.

Direct support through Discord

Builders who experience problems or have questions can reach Juraci through the Future Caribbean Discord.

He said he is happy to answer questions in the general channel, through a dedicated partner channel if one is created, or privately when appropriate. His preference is for questions to be discussed publicly where possible, since other builders may encounter the same issue and benefit from the solution.

Instrument from the beginning

Juraci closed the onboarding session with one of the most important recommendations of the call: do not wait until something breaks in production before thinking about observability.

Instrumentation should be treated as part of the development lifecycle from the beginning. Just as teams think about security and code quality while writing software, they should also think about whether they will be able to understand that software once it is running.

Rose and the OllyGarden OpenTelemetry Agent Skills are designed to make that process easier.

For Future Caribbean builders creating agentic AI applications, that means building not only applications that work, but applications that teams can actually understand, monitor, debug, and improve after deployment.