Your coding agent
Investigates evidence, changes code, runs experiments, and proposes the next iteration.
add Recursive Self Improvement To Your Application
Give your favorite coding agent the auditable telemetry, evaluation datasets, skills, and execution history needed for recursive self improvement, with Junjo.
Open SourceApache 2.0
Junjo Python SDK
Installed in your application.
AI application building blocks and telemetry instrumentation for recursive self improvement.
- Keep your coding agent
- Keep your agent framework
- Or build fully with Junjo
Junjo AI Studio
Lightweight telemetry and data layer.
High performance telemetry and evaluation suite optimized for AI agents and human observation.
- Self-hostYour infrastructure. Your telemetry.
- High performance. Small footprint.Small VM deployment · Shared vCPU · < 1GB RAM
Diagnose failures without hallucination
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.
Replay scenarios against prompt and agent changes, at scale
ABaseline
Failed steps
BCandidate
Passing steps
Optimized for coding agents.
- ChatGPT Codex
- Claude Code
- Pi Agent
- OMP
- OpenCode
- Cursor
- Grok Build
- etc.
Your agent maintains control.
Work through your favorite coding agent. Describe what you want to improve in natural language.
Your coding agentExample request
You
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.
- 01
Coding agent
Your chosen coding agent
- 02
Junjo CLI
Optimized for agents
- 03
Detailed chronology
Audit the events in context
- 04
Code changes
Improve your application
- 05
Run again & compare
Assess outcome differences in detail
Build Targeted Datasets
Rapidly test and eval changes.
Give your coding agent 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.
Describe what you want to test.
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.”
Build on real usage. Explore new scenarios.
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.
Define success and keep it consistent.
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.
Ask your agent to run the evaluation.
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.
Make a change. Ask what improved.
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.
Find a simpler path to better results.
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.
Shop supportAI assistant
Monolithic Agent Query
GPT-6 Astra Medium
- Accuracy
- 94%
- Execution
- 20s
- Job cost
- $0.12
Optimized With Junjo
GPT-5.6 Luna High
- Accuracy
- 95%
- Execution
- 3s
- Job cost
- $0.0025
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.
Building blocks
for improving AI apps
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.
Scale and optimize high-volume repetitive tasks.
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.
Give each specialist its own improvement cycle.
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 |
Parallel calls. One shared application state.
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.
Follow every state change through execution.
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
- order_summary
- null
- policy_eligible
- null
- paid_amount
- null
- resolution
- null
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
- order_summary
- "Delivered · damaged item"
- policy_eligible
- null
- paid_amount
- null
- resolution
- null
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
- order_summary
- "Delivered · damaged item"
- policy_eligible
- true
- paid_amount
- null
- resolution
- null
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
- order_summary
- "Delivered · damaged item"
- policy_eligible
- true
- paid_amount
- 79
- resolution
- null
State update · Store action · Originating operation
State diff
Update 4 · Synthesis node → record_resolution()
−"resolution": null
+"resolution": "Refund eligible"
Application state after update 4
- order_summary
- "Delivered · damaged item"
- policy_eligible
- true
- paid_amount
- 79
- resolution
- "Refund eligible"
State update · Store action · Originating operation
Build the application. Or extend the one you have.
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
Extend your agent framework
with Junjo.
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
Your OpenAI agent. Junjo tools inside.
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 toolsJunjo SDKWorkflow or specialist agent
Tool call Result
Shared execution telemetryJunjo AI Studio
Coming soonPython SDK
Add Junjo to your agent’s tools.
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 toolsJunjo SDKWorkflow or specialist agent
Tool call Result
Shared execution telemetryJunjo AI Studio
Coming soonPython SDK
Extend a step in your existing graph.
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 toolsJunjo SDKWorkflow or specialist agent
Tool call Result
Shared execution telemetryJunjo AI Studio
Coming soonPython SDK
Typed tools. Explicit inputs and results.
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 toolsJunjo SDKWorkflow or specialist agent
Tool call Result
Shared execution telemetryJunjo AI Studio
Coming soonTypeScript · Planned
Keep your TypeScript application.
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.
Junjo SDKWorkflow or specialist agent
Python service call Result
Shared execution telemetryJunjo AI Studio
Coming soonPython SDK
Give your Claude agent Junjo tools.
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 toolsJunjo SDKWorkflow or specialist agent
Tool call Result
Shared execution telemetryJunjo AI Studio
Start with your existing application. Add Junjo capabilities one at a time.
Call any model,
however you want
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.
Model providers
Use their SDKs or compatible APIs.
- OpenAI
- Anthropic
- Google Gemini
- xAI
- Mistral
- DeepSeek
- Qwen
- Kimi
- Z.ai
- MiniMax
Model libraries
Keep your abstractions and structured output tools.
- LiteLLM
- Instructor
Gateways & inference
Call through your cloud, gateway, or local model server.
- OpenRouter
- Amazon Bedrock
- Azure AI
- Vertex AI
- Groq
- Ollama
- vLLM
Your application makes the model calls. Junjo connects instrumented execution to state updates, traces, and evaluation outcomes.
Your coding agent investigates.
You can inspect the evidence.
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.
Junjo instrumented refund workflow
Your coding agent’s investigation
Junjo AI Studio
Investigate improper AI outcome from the production application’s telemetry stored in Junjo AI Studio.
Refund workflow
Order history
Product policy
Payment ledger
Synthesis
Product policy Input → Output
- Item condition
- Damaged on arrival
- Selected policy
- Standard return
- Decision
- Refund rejected
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.
Rerun the eval scenarios with updated prompts and code.
3Passed
0Failed
| Scenario | Outcome |
|---|---|
| Damaged item | Passed |
| Missing receipt | Passed |
| Partial return | Passed |
Evaluation reason Damaged item
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.
Inspectable evidence of improved state handling.
| Scenario | Before | After |
|---|---|---|
| Damaged item | Failed | Passed |
| Missing receipt | Passed | Passed |
| Partial return | Passed | Passed |
Execution state Damaged-item case
− policy: standard_return
+ policy: damaged_item
Proof of a real improvement without regressions across these scenarios. No whack-a-mole.
Make every experiment useful to the next one.
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.
Earlier experiment
Revision · Results · Traces
Previous experiment
Revision · Results · Traces
Latest experiment
Revision · Results · Traces
The history remains available to both your coding agent and your team.
Keep your coding agent.
Keep your application stack.
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.
Develop & improve
Your application
Executes its real workflows, tools, dependencies, and evaluators.
Junjo
Supplies telemetry, evaluation tooling, datasets, results, and queryable execution evidence.