GitHub open-sourced Myli: a harness for AI design agents

EightPotions has open-sourced Myli, a provider-neutral, pre-alpha Python harness designed for AI agents that propose RFC 6902 JSON Patch changes to application-owned design documents. As detailed in github.com's report, the framework is explicitly built around a strict safety boundary: it never persists or applies any returned candidate patch directly to application state.

This standalone release addresses the growing need for specialized harnesses when building design-focused AI assistants, structural document editors, and visual workflow tooling. The codebase remains independent of specific model providers, object-relational mappers, canvas representations, Pydantic, progress transports, rendering stacks, or persistence mechanisms, offering developers a modular baseline for document-level agentic execution.

GitHub open-sourced Myli: what actually changed

The release of Myli introduces a dedicated Python framework tailored specifically for structured JSON manipulation via LLM agents. Rather than allowing models to direct-write to data stores, Myli acts as an intermediate execution environment that manages contract runs using the myli.run entry point. The harness processes a request, current design, authorization flags, capability maps, event handles, and step persistence callbacks to emit a comprehensive RunResult. This result encapsulates the user-facing message, an optional validated candidate patch, changed status flags, tool outcomes, and provider metadata without altering the underlying application state.

To enforce precise data guarantees, Myli separates trusted stored inputs from untrusted model candidates via its DesignSpec architecture. Untrusted JSON candidate output is validated at runtime against an authoritative schema and must serialize back cleanly without silent rewrites, default insertions, field dropping, or type coercion. For large schemas, developers can opt into prompt_schema to pass lightweight representations to the model prompt while retaining the full schema for backend verification. Stored inputs may also configure dedicated migrators and normalizers before each run starts.

GitHub open-sourced Myli: how it works

Myli relies on public protocol abstractions for its core components, including MainModel and VisionModel. By default, the package includes LiteLLMMainModel and LiteLLMVisionModel adapters, allowing applications to plug in custom endpoints, credentials, fakes, or transports. The LiteLLM implementation supports text, JSON, and structured output modes while converting provider-level failures into Myli's stable exception hierarchy. It canonicalizes object keys deterministically and preserves array and conversation ordering to ensure prompt caching compatibility across model runs.

Context management is governed by an injectable ModelContextPolicy. After three completed main-model calls, Myli's default context policy automatically compacts superseded visual renders while retaining current candidate references, unresolved findings, authorization evidence, and tool errors. Compact records preserve run-scoped evidence_ref identifiers, allowing models to retrieve raw evidence or RFC 6901 subtrees on demand via the bounded retrieve_evidence tool. Visual reviews use VisualReviewRequest to manage labeled multi-image payloads, supporting optional multi-page document rendering through render_pages.

GitHub open-sourced Myli: why it matters now

As developer workflows shift toward agentic document editing, securing application state against model hallucinations and invalid structural mutations has become a central challenge. Myli provides a structural sandbox where tools, candidate policies, and middleware inspect every proposal before execution. Tools declare explicit capability requirements, execution timeouts, call budgets, and byte-size limits. By enforcing strict projections with model_view, Myli returns minimal JSON to the model while preserving full execution traces for audit logs and application middleware.

The architecture also standardizes visual feedback loops without exposing binary assets to model traces. When an application configures a renderer and vision model, Myli validates proposals and policy constraints prior to rendering previews. The main model can ground questions against rendered artifacts or pass base_render_ref identifiers to compose sequential patch chains against original documents. By managing asset search budgets, provenance tracking, and cached previews through generic Asset providers, Myli brings deterministic safety and observable execution to complex visual design agents.

GitHub open-sourced Myli: who is affected

Software engineers building visual design editors, canvas applications, CAD assistants, and complex configuration tools can adopt Myli as a lightweight foundation. Because the harness does not depend on Pydantic, ORMs, or specific canvas formats, engineering teams can integrate Myli into existing Python backend architectures without refactoring persistent domain models. Developers using LiteLLM gain out-of-the-box support for multimodal messaging, structured candidate parsing, and cache-control injection points across popular foundation models.

Security and system architects also benefit from Myli's explicit authorization and middleware hooks. The ToolMiddleware interface allows applications to evaluate rate limits, tenant boundaries, transactional approvals, and audit requirements exactly once per model work phase, even when tools execute in parallel. Furthermore, CandidatePolicy runs before proposals render or final candidates return, giving developers complete programmatic control over whether a model's proposed JSON patch is accepted, deferred, or rejected.

GitHub open-sourced Myli: what to watch

As a pre-alpha open-source project, Myli's initial release sets the stage for broader ecosystem integration and community extensions. Developers should monitor the project repository for updates to default provider adapters, expanded middleware patterns, and performance optimizations around prompt schema validation. Future iterations may expand built-in integration modules, such as PydanticDesignSpec, providing deeper bindings for teams that rely on Pydantic schemas across their broader application stacks.

Key metrics to track in production adoption include tool execution reliability, compaction efficiency during long multi-turn design sessions, and latency overhead introduced by visual rendering loops. As design-agent workflows mature, Myli's provider-neutral contract offers a practical blueprint for decoupling AI reasoning from persistent application storage while keeping human developers in firm control of state mutations.