Give your favorite coding agent the auditable telemetry, evaluation datasets, skills, and execution history needed for recursive self improvement, with Junjo.
Installed in your application.
AI application building blocks and telemetry instrumentation for recursive self improvement.
Lightweight telemetry and data layer.
High performance telemetry and evaluation suite optimized for AI agents and human observation.
Connect application outcomes to the execution chronology that produced them. Your coding agent can replay events, inspect the sequence of operations, investigate intermediate results, and identify which step needs to change.
This telemetry and diagnostic layer is the primary foundation of recursive self improving apps.
Failed steps
Passing steps
Work through your favorite coding agent. Describe what you want to improve in natural language.
Investigate the failed cases in our refund workflow, make a targeted improvement, and compare it against the baseline.
Junjo includes skills so your coding agent knows exactly how to run a self-improvement cycle.
Your chosen coding agent
Optimized for agents
Audit the events in context
Improve your application
Assess outcome differences in detail
Make eval-driven development practical with repeatable scenarios for the application behavior you want to improve. Target an entire application, a workflow, an agent, or a single operation. Store the cases and evaluation criteria in Junjo, then run them against changes in your own application environment.
Your Agent Creates and Stores Datasets
Run the scenarios through your local code changes
Every run recorded for comparison
Keep the test cases consistent while your implementation changes. Junjo connects each evaluation outcome to its execution chronology, so you and your coding agent can investigate differences throughout the flow.
Ask your coding agent in natural language. Tell it which behavior matters and what a good outcome looks like. Your agent turns that request into a targeted dataset.
“Create a refund evaluation dataset from our recent failed requests. Add scenarios for missing receipts, partial returns, and policy exceptions.”
Your coding agent can use available execution history and real-world examples to author cases, or create synthetic scenarios that explore behavior you have not encountered yet. Combine common requests, known failures, and edge cases in the same dataset.
Work with your coding agent to define the evaluation criteria. Generated answers are examples, not automatically the correct outcome. Have your agent lock the dataset in Junjo so later experiments use the same cases and criteria.
Your coding agent retrieves the dataset and runs it through your application and evaluators in your own environment. Junjo stores the outcomes and linked execution evidence, keeping the results available for investigation and comparison.
Ask your coding agent to test a code or prompt change against the same dataset. It can compare outcomes, investigate the traces behind regressions, and explain what the experiment revealed before choosing the next improvement.
Recursive self improvement starts with a single prompt. Junjo’s evaluation datasets, evaluator telemetry, and coding-agent skills let your agent target failure modes, generate scenarios, build evaluator judges, and run experiments.
Your coding agent owns and runs the code. Junjo AI Studio coordinates the experiment data and telemetry as a single source of truth across multiple agents, work trees, and team members. Scale up and run unlimited fan-out recursive self improvement cycles in parallel.
Use Junjo to investigate recent customer service agent failures, build evaluator judges and datasets of new scenarios based on our customer interactions, and iterate until we handle these correctly.
Cases passed / cases evaluated
| Failure mode | Baseline | Experiment 01 | Experiment 02 | Experiment 03 | Refined flow |
|---|---|---|---|---|---|
| Damaged items | 0 / 10 | 2 / 10 | 6 / 10 | 8 / 10 | 10 / 10 |
| Missing receipts | 2 / 10 | 4 / 10 | 7 / 10 | 9 / 10 | 10 / 10 |
| Partial returns | 1 / 10 | 3 / 10 | 4 / 10 | 7 / 10 | 9 / 10 |
| Already refunded | 4 / 10 | 5 / 10 | 8 / 10 | 9 / 10 | 10 / 10 |
| Split payments | 0 / 10 | 2 / 10 | 4 / 10 | 6 / 10 | 9 / 10 |
| Expired return windows | 3 / 10 | 4 / 10 | 6 / 10 | 8 / 10 | 10 / 10 |
| Gift returns | 2 / 10 | 3 / 10 | 5 / 10 | 8 / 10 | 9 / 10 |
| Policy exceptions | 0 / 10 | 1 / 10 | 4 / 10 | 7 / 10 | 9 / 10 |
| Overall pass rate | 15% | 30% | 55% | 78% | 95% |
Each experiment gives your coding agent evidence for the next one. It can harvest failure modes from application telemetry, turn them into targeted datasets and evals, and test prompt or code changes against a baseline.
Investigate production execution history and evaluation failures to identify the behavior that needs attention.
Create scenarios from observed failures, add synthetic variations, and define what success means. Lock the dataset to keep subsequent experiments comparable.
Run prompt and code changes through the same cases. Inspect the outcomes and traces, check for regressions, and use the findings to guide the next change.
Schedule this cycle through your coding agent’s automation or your existing scheduler. Ask it to harvest new failure modes, develop datasets and evals, run experiments with prompt changes, and report the evidence.
Your coding agent orchestrates the work; your application runs it; Junjo preserves the data for the next cycle.
Unleash recursive self improvement with fan-out strategies to test multiple architectures and approaches at once, or to handle several failure modes in parallel.
Run independent recursive self improvement cycles for feature_a, feature_b, failure_mode_1, and failure_mode_2. Each coding agent works in its own work tree, harvesting failures, running experiments, evaluating outcomes, and improving its target with Junjo. Junjo AI Studio brings their results and telemetry together so you can compare improvements and direct the next round of work.
Execution evidence helps your coding agent identify requests that mix too many responsibilities. Junjo helps you strategically break down monolithic agent steps into simpler tasks that can be individually evaluated and iterated on.
GPT-6 Astra Medium
GPT-5.6 Luna High
A powerful model can take on a complex request. Junjo helps your coding agent explore how to accomplish the same task with smaller, cheaper, faster models—and evaluate whether the new flow performs better.
Junjo’s Python SDK's building blocks include specialist agents, structured workflows, dynamically traversed graphs, and an application state management system. These are used by your coding agent to break down monolithic prompts into optimized flows, with granular control and observability.
Build structured workflows from a graph of nodes and conditional edges. An LLM can interpret a request and write its routing decision into application state. The graph dynamically traverses the matching edges, combining LLM reasoning with explicit application logic.
Turn repeated application tasks into reusable execution paths. Keep the operations predictable, route each request through the work it needs, and evaluate individual nodes or the complete workflow as you optimize for volume, latency, and quality.
Explore structured workflowsChange the scenario to follow the LLM’s routing decision.
state.route = "clarify" Ask the customer
The intake LLM identifies missing information and records route = "clarify". The matching conditional edge leads to a clarification step.
state.route = "resolve" Resolve the request
The intake LLM records route = "resolve" in application state. The matching edge continues to refund assessment.
state.route = "review" Specialist review
The intake LLM identifies an exception and records route = "review". The graph follows the edge to specialist review.
Junjo gives your coding agent the building blocks and execution evidence to split a monolithic agent into focused subagents—and improve each one through repeated evaluation. Build a dataset for a specialist, run its scenarios, inspect failures in its execution chronology, and refine its prompts, tools, or model against the same cases.
For a support application, this means separate product support, exchange request, and order status specialists, each with its own prompts, tools, and evaluation targets. Your coding agent can test changes and smaller models locally, compare quality, latency, and cost, then rerun the full flow to check whether the improvement holds across the application.
Explore specialist agents| Domain prompt | Troubleshoot the product using its documentation. |
|---|---|
| Domain tools | search_product_docs · get_product_specs |
| Evaluation dataset | Product support datasetSetup issues · compatibility · damaged items |
| Domain prompt | Apply exchange rules and find a suitable replacement. |
|---|---|
| Domain tools | check_exchange_policy · find_replacement |
| Evaluation dataset | Exchange request datasetWithin policy · expired window · unavailable replacement |
| Domain prompt | Explain fulfillment and delivery status from order records. |
|---|---|
| Domain tools | get_order · track_shipment |
| Evaluation dataset | Order status datasetDelayed delivery · split shipments · delivered orders |
Junjo’s RunConcurrent building block makes parallel calls a simple composition pattern: group independent nodes or subflows, let their work overlap, and bring their results into the same workflow state through store actions.
Junjo validates and serializes state commits against the latest state, so independent field updates do not overwrite each other. Spend less time coordinating asynchronous results and more time improving the work each call performs.
Explore concurrent executionConcurrent execution. Shared state. Individually validated commits.
Inspired by Redux and the Elm Pattern, Junjo combines typed state, detached read snapshots, and explicit store actions for safe updates in high-concurrency LLM applications. Each committed change records a chronological state diff and the operation that produced it.
Inspect the application state at successive updates: what changed, in which order, and through which action. Give your coding agent the detailed execution history it needs to explain a decision and diagnose the step behind a failure.
Explore state managementStep through state updates to inspect each diff and the state it produced.
State diff
Initial state · Workflow started
The workflow starts with its own isolated state.
Initial application state
State update · Store action · Originating operation
State diff
Update 1 · Order history node → record_order()
−"order_summary": null
+"order_summary": "Delivered · damaged item"
Application state after update 1
State update · Store action · Originating operation
State diff
Update 2 · Product policy node → record_policy()
−"policy_eligible": null
+"policy_eligible": true
Application state after update 2
State update · Store action · Originating operation
State diff
Update 3 · Payment ledger node → record_payment()
−"paid_amount": null
+"paid_amount": 79
Application state after update 3
State update · Store action · Originating operation
State diff
Update 4 · Synthesis node → record_resolution()
−"resolution": null
+"resolution": "Refund eligible"
Application state after update 4
State update · Store action · Originating operation
Junjo supplies the ingredients for a complete agentic application: agents, tools, structured workflows, graphs, concurrency, state management, telemetry, and evaluation.
These same building blocks can act as tools and support layers for your existing agent framework. For example, expose a Junjo workflow or agent as an OpenAI Agents SDK tool, while the outer framework keeps its conversation, sessions, and agent loop.
Explore the OpenAI Agents SDK integrationBuild with Junjo directly, or expose a capability to an existing framework.
The ingredients for a complete agentic application.
Compose agents, tools, workflows, concurrency, and state in your Python application. Trace and evaluate the resulting execution.
Junjo agent → Application tool → Junjo workflow
A support layer for your existing agent framework.
Expose a Junjo agent or workflow as an OpenAI Agents SDK function tool. The outer agent keeps its sessions and conversation; the nested execution keeps its state and evidence.
OpenAI Agents SDK → Tool call → Junjo workflow
Keep your existing agents, conversations, and tools. Connect their execution to Junjo AI Studio, and expose Junjo SDK workflows or specialist agents as tools to go deeper in recursive self improvement optimization.
Available for PythonOpenAI Agents SDK
Expose a Junjo SDK workflow or specialist agent as a native function tool. The OpenAI Agents SDK keeps its agent loop, sessions, handoffs, and guardrails.
OpenAI agent activity and nested Junjo execution appear together in Junjo AI Studio through one OpenTelemetry pipeline.
Explore the OpenAI Agents SDK integration
OpenAI Agents SDKAgent loop · Existing toolsTool call Result
Coming soonPython SDK
The planned Python integration will expose Junjo SDK capabilities through LangChain’s tool interface, alongside the tools and agent behavior you already use.
Connect LangChain activity and nested Junjo execution to the same Studio chronology.
LangChainAgent loop · Existing toolsTool call Result
Coming soonPython SDK
The planned Python integration will let a selected graph operation invoke a Junjo SDK capability. LangGraph retains the surrounding graph, routing, and persistence.
Connect the outer graph and the work performed inside its Junjo capability in Studio.
LangGraphAgent loop · Existing toolsTool call Result
Coming soonPython SDK
The planned Python integration will expose Junjo SDK capabilities through typed tools while preserving your Pydantic AI agent, dependencies, and output contracts.
Connect the framework’s OpenTelemetry instrumentation and nested Junjo execution to Studio.
Pydantic AIAgent loop · Existing toolsTool call Result
Coming soonTypeScript · Planned
A planned service integration will connect server-side tool calls to Python-based Junjo SDK capabilities, while your application retains its streaming experience.
Junjo currently supports Python. Vercel AI SDK support is coming soon; this is a planned service boundary, not an available TypeScript SDK.
Python service call Result
Coming soonPython SDK
The planned Python integration will expose Junjo SDK capabilities through the Claude Agent SDK’s supported tool interfaces, retaining its agent execution and session management.
Connect agent activity and the Junjo capabilities it invokes to Studio through application telemetry.
Claude Agent SDKAgent loop · Existing toolsTool call Result
Start with your existing application. Add Junjo capabilities one at a time.
Call models the way you already do: directly through a provider’s SDK, through a library such as LiteLLM, or through a gateway such as OpenRouter. Junjo adds structured execution, shared state, and auditable telemetry around those calls.
Choose the right model for each step, then compare quality, latency, and cost against the same evaluation datasets. Improve your application while keeping control of how you access and use models.
Use their SDKs or compatible APIs.
Keep your abstractions and structured output tools.
Call through your cloud, gateway, or local model server.
Your application makes the model calls. Junjo connects instrumented execution to state updates, traces, and evaluation outcomes.
Give your coding agent access to the execution history and evaluation outcomes needed to orchestrate a recursive self improvement cycle. It can investigate failures, make targeted changes, run evaluations, and explain the results with deep links into Junjo AI Studio.
You and your coding agent can look at the same data, down to the operations, intermediate results, and state changes behind an outcome.
Use the failed request and its execution evidence to create an eval case. Define the expected outcome, then include it with the existing scenarios to test the fix and check for regressions.
| Scenario | Outcome |
|---|---|
| Damaged item | Passed |
| Missing receipt | Passed |
| Partial return | Passed |
The damaged-item policy was applied and the refund was approved.
Validate that the added failure scenario is now handled properly and that existing scenarios have no regressions.
| Scenario | Before | After |
|---|---|---|
| Damaged item | Failed | Passed |
| Missing receipt | Passed | Passed |
| Partial return | Passed | Passed |
− policy: standard_return
+ policy: damaged_item
Proof of a real improvement without regressions across these scenarios. No whack-a-mole.
Keep each dataset and its case outcomes connected to the application revisions and execution traces that produced them. Your coding agent can follow a case across previous runs, investigate recurring failures, and use that history to choose its next change.
Each iteration adds evidence that helps guide the next experiment.
Revision · Results · Traces
Revision · Results · Traces
Revision · Results · Traces
The history remains available to both your coding agent and your team.
Run experiments in your application codebase, with your existing agent framework and preferred coding agent. Junjo supplies the telemetry and evaluation building blocks that make the results auditable and comparable.
Investigates evidence, changes code, runs experiments, and proposes the next iteration.
Executes its real workflows, tools, dependencies, and evaluators.
Supplies telemetry, evaluation tooling, datasets, results, and queryable execution evidence.
