quenda 0.3.9

A lightweight, layered Agent framework for Python

What's New

2026-09 (v0.3.6)

• Memory Evolution — Corrections, bounded consolidation, and audited detailed Markdown memory.
• Skill Evolution — Governed creation and revision of reusable Skills.
• Runtime & Web Reliability — Stronger continuation, compaction, streaming, MCP, and session workflows.

2026-08 (v0.3.4)

• Web UI — A FastAPI gateway + React dashboard for agents, sessions, workspaces, and settings. quenda web for foreground use, quenda gateway for a background service.
• Self-Evolution Platform — Post-run memory evolution with automatic/review/disabled write modes, plus staged skill proposals with validation and rollback.
• Config-Driven Providers — Declare builtin overrides, custom OpenAI-compatible endpoints, and local llama-server presets directly in config.yaml (ADR-035).

2026-06 (v0.3.0)

• Skills Framework — Composable capability packages with instructions, resources, and tools. Discover, activate, and use skills on demand. Learn more →
• Context Compression — Automatic summarization when context grows large, with configurable policies and manual /compress command.
• Interaction Requests — LLM can ask users for choices, confirmations, and input via structured interaction protocol.
• Custom Tool Extensions — Agent-local tools via extensions/tools/*.py with config.yaml declaration.
• Policy System — Runtime policies for termination, tool selection, and result processing.
• Multimodal Support — Image input support with resource activation.
• 26 Model Providers — OpenAI, Anthropic, DeepSeek, DashScope, Moonshot, Ollama, and 20 more.

Quenda Code

Quenda Code is an AI coding agent that runs in your terminal. It reads your codebase, writes code, runs commands, and helps you ship.

📖 Quenda Code Documentation →

# Install
pip install quenda quenda-code

# Start interactive session
quenda code

# One-shot task
quenda code "Add error handling to the API client"

Personal Agents

Create a long-lived local agent with its own prompts, skills, memory, sessions, and default workspace:

quenda agent create reviewer
quenda reviewer

Seed an independent agent from an installed package or source directory:

quenda agent create coder --from quenda-code
quenda agent create writer --from ./agents/writer

Agents live under ~/.quenda/agent-<name>/. Without --workspace, they work inside their own workspace/; the same agent can enter a project explicitly:

quenda reviewer --workspace ~/Workspace/my-project

Features

• Code-aware — Reads and understands your codebase structure
• Workspace-aware — File tools resolve paths against the selected project; local execution follows explicit permissions and trust policy
• Explicit execution trust — Local shell/Python run as local-trusted; strong isolation must use a future isolated backend
• Session persistence — Conversations saved and resumable
• Interactive mode switching — Switch between code, architect, and chat modes
• Skills on demand — Activate capability packages as needed

REPL Commands

Example Session

> read the main entry point and explain how it works

I'll read the main entry point...

[Reads src/quenda/cli.py]

The entry point is `cli.py:main()`. It defines two subcommands:
- `quenda run --agent <path>` — Run a custom agent from AGENT.md
- `quenda code` — Run Quenda Code Agent (built-in)

Each command supports one-shot mode (with a message) or REPL mode (without).

> add a --version flag to the CLI

I'll add a `--version` flag to the argument parser...

[Applies patch to cli.py]

Done. Added `--version` flag that prints the version and exits.

> run the tests

[Runs pytest]

All 42 tests passed.

Quenda SDK

Build agents in Python with a minimal API:

from quenda import Agent, tool
from quenda.providers import get_provider_registry
from quenda.tools import get_core_tools
import asyncio

@tool
def calculate(expression: str) -> float:
    """Safely evaluate a math expression."""
    import ast
    node = ast.parse(expression, mode='eval')
    return eval(compile(node, '<string>', 'eval'), {"__builtins__": {}}, {})

model = get_provider_registry().get_model("deepseek", "deepseek-v4-flash")

agent = Agent(
    name="assistant",
    system_prompt="You are a helpful assistant.",
    tools=[calculate, *get_core_tools(".")],
    model=model,
)

async def main():
    session = agent.open_session()
    result = await session.send("What is 15% of 847?")
    print(result)

asyncio.run(main())

Failed text calls (Session.send, send_sync, and Agent.run) raise quenda.RunFailedError, which exposes run_id and the normalized error event. Use Session.send_collecting() when handling completion, errors, pauses, and interruptions through events. Concurrent writes to a stored session are rejected; reload a session after a storage revision conflict.

📖 SDK Tutorials — 8 chapters covering agents, tools, providers, sessions, and events.

Installation

# Quenda Code — AI coding assistant (CLI)
pip install quenda quenda-code

# Quenda SDK — Build agents in Python
pip install quenda

Requires Python 3.12+. Runtime dependencies are installed automatically; see pyproject.toml.

Web UI

A FastAPI gateway plus React dashboard to manage agents, sessions, workspaces, and settings from the browser:

pip install "quenda[web]"   # optional dependencies

quenda web --port 8000      # foreground (dev)

quenda gateway start        # background service
quenda gateway status
quenda gateway logs
quenda gateway stop

Pages cover agents (create/edit/detail with model picker), sessions (chat with streaming events), workspaces, and settings. Sessions run through the same Host layer as the CLI.

Features

• Minimal API. Agent, Session, @tool, and you're done.
• 27 model providers. OpenAI, Anthropic, DeepSeek, DashScope, and more — one registry, one API.
• Core tools. Filesystem, local-trusted shell/Python, and user interaction.
• Skills framework. Composable capability packages with instructions and resources.
• Explicit security contracts. SSRF protection, command filtering, permissions, and fail-closed isolation requirements.
• Observable by default. Every run emits structured events for streaming and debugging.
• Context compression. Automatic summarization when context grows large.
• Self-evolution. Post-run memory writes and staged skill proposals, auditable and roll-back-able.
• Config-driven providers. Built-in overrides, custom OpenAI-compatible endpoints, and llama-server presets in config.yaml.
• Web UI. Optional FastAPI/React dashboard with quenda web and quenda gateway.

Model Providers

Quenda ships with 27 built-in providers covering 300+ models:

Full provider list →

Add a custom provider in 5 lines:

from quenda.providers import ProviderSpec, ModelSpec, get_provider_registry

registry = get_provider_registry()
registry.register(ProviderSpec(
    id="my-provider",
    name="My Provider",
    base_url="https://api.example.com/v1",
    api="openai-completions",
    api_key="${MY_API_KEY}",
    models=(ModelSpec(id="my-model", name="My Model", tool_calling=True),),
))

Agents can also declare providers in config.yaml — a builtin override, a custom OpenAI-compatible endpoint, or a llama-server preset — and select roles with models.default / models.vision using provider/model (ADR-035):

providers:
  openai:
    api_key: "${OPENAI_API_KEY}"

  local-llama:
    type: llama-server
    url: http://127.0.0.1:8080/v1
    models:
      - id: "qwen3.5:9b"
        tool_calling: true

models:
  default: openai/gpt-4o
  vision: local-llama/qwen3.5:9b

Built-in Tools

get_core_tools(workspace) returns 11 essential framework tools:

Full tool reference →

Architecture

Interface → Host → Runtime → Kernel

Each layer depends only on the layer inside it. The Kernel is fully testable with fake models — no network required.

Framework self-description is generated from the code-owned capability registry. Maintainers can update or verify the checked-in artifacts with:

quenda capabilities --generate-artifacts .
quenda capabilities --check-artifacts .

Documentation

Contributing

Quenda is intentionally small. Before making a change, read CLAUDE.md and the ADR records.

1. Identify which architectural layer owns the change.
2. Prefer the smallest complete change; add tests with behavior changes.
3. Do not cross established layer boundaries.

pip install -e ".[dev]"   # editable install with dev tooling
pytest                    # run tests
ruff check src/quenda       # lint

License

MIT