{"id":49754922,"url":"https://github.com/hecatehq/hecate","last_synced_at":"2026-07-12T02:00:54.256Z","repository":{"id":352693234,"uuid":"1215999715","full_name":"hecatehq/hecate","owner":"hecatehq","description":"Local AI operations console for supervised agent work.","archived":false,"fork":false,"pushed_at":"2026-07-06T19:43:27.000Z","size":122569,"stargazers_count":22,"open_issues_count":1,"forks_count":1,"subscribers_count":2,"default_branch":"master","last_synced_at":"2026-07-06T20:09:53.854Z","etag":null,"topics":["acp","ai","ai-gateway","ai-harness","ai-runtime","llm","llm-gateway","mcp-client","mcp-server","opentelemetry","task-runner"],"latest_commit_sha":null,"homepage":"https://hecate.sh","language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/hecatehq.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":"SECURITY.md","support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null}},"created_at":"2026-04-20T13:15:36.000Z","updated_at":"2026-07-06T19:43:38.000Z","dependencies_parsed_at":"2026-06-07T19:02:03.335Z","dependency_job_id":null,"html_url":"https://github.com/hecatehq/hecate","commit_stats":null,"previous_names":["chicoxyzzy/hecate","hecatehq/hecate"],"tags_count":48,"template":false,"template_full_name":null,"purl":"pkg:github/hecatehq/hecate","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hecatehq%2Fhecate","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hecatehq%2Fhecate/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hecatehq%2Fhecate/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hecatehq%2Fhecate/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hecatehq","download_url":"https://codeload.github.com/hecatehq/hecate/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hecatehq%2Fhecate/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":35379591,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-07-12T02:00:06.386Z","response_time":87,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["acp","ai","ai-gateway","ai-harness","ai-runtime","llm","llm-gateway","mcp-client","mcp-server","opentelemetry","task-runner"],"created_at":"2026-05-10T19:57:43.312Z","updated_at":"2026-07-12T02:00:54.248Z","avatar_url":"https://github.com/hecatehq.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003ch1 align=\"center\"\u003e\n  \u003cimg src=\"docs/assets/brand/hecate-lockup-horizontal-dark-2x.png\" alt=\"Hecate - Agent Operations Console\" width=\"720\"\u003e\n\u003c/h1\u003e\n\n[![Latest release](https://img.shields.io/github/v/release/hecatehq/hecate?include_prereleases)](https://github.com/hecatehq/hecate/releases)\n[![Container](https://img.shields.io/badge/Container-ghcr.io-2496ED?logo=docker\u0026logoColor=white)](docs/operator/deployment.md#image-pinning)\n[![Test](https://github.com/hecatehq/hecate/actions/workflows/test.yml/badge.svg)](https://github.com/hecatehq/hecate/actions/workflows/test.yml)\n[![Go Report Card](https://goreportcard.com/badge/github.com/hecatehq/hecate)](https://goreportcard.com/report/github.com/hecatehq/hecate)\n[![Go version](https://img.shields.io/github/go-mod/go-version/hecatehq/hecate)](go.mod)\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)\n[![OpenTelemetry](https://img.shields.io/badge/OpenTelemetry-enabled-f5a800?logo=opentelemetry\u0026logoColor=white)](https://opentelemetry.io/)\n\n\u003cp align=\"center\"\u003e\n  \u003cstrong\u003eAgent operations console and local runtime control plane.\u003c/strong\u003e\u003cbr\u003e\n  Run Hecate between operators, AI clients, agent runtimes, model providers,\n  and local workspaces so agent work can be routed, supervised, approved,\n  traced, and reviewable.\n\u003c/p\u003e\n\n\u003e **Status: public alpha.** Hecate is useful today for model-provider routing,\n\u003e Hecate Chat, External Agent sessions, project-scoped work, approvals,\n\u003e artifacts, usage, and observability. It is not production-stable\n\u003e infrastructure yet: workflow runbooks, richer Agent Presets, browser QA, and\n\u003e sandbox hardening are still design or early-alpha work. Read\n\u003e [known limitations](docs/operator/known-limitations.md) before depending on it.\n\n## Contents\n\n- [What Hecate Is](#what-hecate-is)\n- [Positioning](#positioning)\n- [System Shape](#system-shape)\n- [Current Capabilities](#current-capabilities)\n- [Quick Start](#quick-start)\n- [Use The Console](#use-the-console)\n- [Project, Context, And Memory Flow](#project-context-and-memory-flow)\n- [Architecture And Docs](#architecture-and-docs)\n- [Status And Roadmap](#status-and-roadmap)\n- [Contributing](#contributing)\n- [License](#license)\n\n## What Hecate Is\n\nHecate is the operator-facing runtime layer for AI work. It gives you one local\nplace to talk to models, run Hecate-native agent tasks, supervise external agent\nCLIs, inspect project context, approve risky actions, collect evidence, and see\nwhat happened after the run.\n\nHecate is local-first in the operational sense: the runtime and UI run on your\nmachine, Hecate-owned state is stored locally, and the gateway binds to loopback\nby default. It is not local-only: you can route to cloud providers and supervise\nexternal coding-agent CLIs that use their own accounts.\n\nHecate is not trying to be the only agent framework in your stack. It is the\nplace where agents, agent frameworks, model calls, local tools, and project\ncoordination become visible and controllable by the operator.\n\nThe short version:\n\n- **Gateway:** one local API for OpenAI-compatible Chat Completions,\n  Anthropic-shaped Messages, model discovery, failover, rate limits, provider\n  health, and usage visibility.\n- **Console:** a React operator UI for Chats, Connections, Tasks, Projects,\n  Usage, Observability, and Settings.\n- **Native runtime:** queued task runs, tool-calling `agent_loop`, approvals,\n  per-call sandbox policy, artifacts, retries, resumes, and event streams.\n- **External Agent supervision:** long-lived local ACP sessions for coding-agent\n  CLIs, with readiness checks, approvals, adapter diagnostics, and Git diff\n  review.\n- **Agent orchestration:** project work, roles, assignments, handoffs, review\n  artifacts, activity health, context snapshots, memory candidates, and\n  operator-gated follow-up.\n- **Evidence:** traces, route reports, task artifacts, diffs, logs, screenshots\n  where available, and final run output close to the decision that produced it.\n\nThe product goal is not just to make model calls. It is to give the operator a\nsingle place to coordinate project-scoped agent work and understand what is\nhappening, what context it used, what it changed, what it cost, what needs\napproval, and where the evidence lives.\n\n## Positioning\n\nHecate sits beside agent frameworks and agent CLIs rather than replacing all of\nthem.\n\n| Question                                 | Hecate answer                                                                                                                                             |\n| ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Is Hecate an agent?**                  | It includes a native task agent loop, but Hecate itself is the operator console and runtime boundary around agent work, not a single autonomous persona.  |\n| **Is Hecate an orchestrator?**           | Yes, when it coordinates projects, assignments, native tasks, external-agent sessions, approvals, handoffs, and reviews. The operator remains in control. |\n| **Is Hecate an agent framework?**        | Not primarily. Hecate exposes APIs and runtime contracts, but it does not require teams to rewrite their agents into a Hecate SDK.                        |\n| **Is Hecate a model gateway?**           | Yes, but the gateway is one subsystem. It exists so chats, tasks, external tools, and compatible clients share routing, policy, usage, and observability. |\n| **Is Hecate a project-management tool?** | No. Projects are a coordination graph for AI work: context, assignments, evidence, memory candidates, reviews, handoffs, and runtime links.               |\n\nThe practical model is:\n\n```text\noperator\n  -\u003e Hecate console / runtime control plane\n    -\u003e model gateway\n    -\u003e Hecate-native task agent loop\n    -\u003e supervised external agent CLIs\n    -\u003e portable project coordination state\n    -\u003e approvals, artifacts, traces, and review evidence\n```\n\nThat makes Hecate useful whether the work is done by Hecate's own task runtime,\nan external coding-agent CLI, a local app using `/v1`, or a future agent system\nthat claims project assignments through a portable coordination server.\n\n## System Shape\n\n```mermaid\nflowchart LR\n    Operator[\"Operator\"] --\u003e Console[\"Browser / desktop console\u003cbr/\u003eserved by Hecate\"]\n    APIClients[\"Compatible API clients\u003cbr/\u003eSDKs · tools · local apps\"]\n\n    subgraph HecateProcess[\"Local Hecate runtime process\"]\n        direction LR\n        HTTP[\"Loopback HTTP server\u003cbr/\u003eembedded UI assets\u003cbr/\u003e/v1 · /hecate/v1\"]\n        Gateway[\"Model gateway\u003cbr/\u003erouting · failover · usage\"]\n        TaskRuntime[\"Hecate task runtime\u003cbr/\u003equeue · agent_loop\u003cbr/\u003eretry/resume\"]\n        AgentSupervisor[\"External Agent supervisor\u003cbr/\u003eACP sessions · diagnostics\"]\n        State[\"Local state\u003cbr/\u003echats · tasks · settings\u003cbr/\u003eruntime overlays\"]\n        Projects[\"Portable project coordination\u003cbr/\u003eembedded Cairnline\"]\n        Evidence[\"Evidence + observability\u003cbr/\u003eapprovals · artifacts · events\u003cbr/\u003eroute reports · trace export\"]\n\n        HTTP --\u003e Gateway\n        HTTP --\u003e TaskRuntime\n        HTTP --\u003e AgentSupervisor\n        HTTP --\u003e State\n        HTTP --\u003e Projects\n        Gateway --\u003e Evidence\n        TaskRuntime --\u003e Evidence\n        AgentSupervisor --\u003e Evidence\n        Projects --\u003e Evidence\n        State --\u003e Evidence\n    end\n\n    Providers[\"Cloud + local model providers\"]\n    Tools[\"Sandboxed workspace tools\u003cbr/\u003eWorkspaceFS · ProcessRunner · GitRunner\"]\n    ExternalCLIs[\"External Agent CLIs / frameworks\u003cbr/\u003eown accounts · own runtime\"]\n\n    Console --\u003e HTTP\n    APIClients --\u003e HTTP\n    Gateway --\u003e Providers\n    TaskRuntime --\u003e Tools\n    AgentSupervisor --\u003e ExternalCLIs\n```\n\nThe runtime is deliberately boring in the good way: request handling, routing,\ntask execution, approvals, artifacts, and telemetry are all ordinary\nsubsystems with memory, SQLite, and Postgres storage parity where persistence\nmatters.\n\n## Current Capabilities\n\n| Surface            | What works today                                                                                                                                                                                                                                                 |\n| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Model gateway**  | OpenAI-compatible Chat Completions, Anthropic-shaped Messages, streaming, vision, model discovery, provider health, failover, retry, usage events, and custom OpenAI-compatible endpoints.                                                                       |\n| **Connections**    | Cloud presets plus Ollama, LM Studio, LocalAI, llama.cpp-compatible servers, local discovery, health checks, credentials, external-agent readiness, and durable approval grants.                                                                                 |\n| **Chats**          | Direct model turns, tools-on task-backed turns, queued prompts, task/run/trace links, inline approvals, inline MCP Apps views, context packet snapshots, project-aware history, and workspace changes with rich per-file diffs.                                  |\n| **Projects**       | Cairnline-backed project identity, roots, context and skill metadata, roles, work items, assignments, handoffs, project memory, review artifacts, and memory candidates, presented through Hecate's native operator cockpit and execution links.                 |\n| **Tasks**          | Native `agent_loop` runs, queue/lease execution, blocking approvals, streamed activity, artifacts, retry/resume, stale-run recovery, MCP tool/App integration, MCP probe, and MCP registry discovery.                                                            |\n| **External Agent** | Supervised local ACP sessions for Codex, Claude Code, Cursor Agent, and Grok Build, including readiness/version checks, prompt-first approvals, adapter diagnostics, cancellation, and Git diff inspect/revert. External agents keep their own accounts/billing. |\n| **Observability**  | OpenTelemetry traces/metrics/logs, response trace headers, local trace view, route reports, runtime stats, timing, token usage, and provider-reported cost where available.                                                                                      |\n| **Desktop app**    | Native bundles run the Hecate runtime as a sidecar. macOS Apple Silicon is launch-tested; Linux and Windows bundles are CI-built but still experimental.                                                                                                         |\n| **Sandbox policy** | WorkspaceFS boundaries, ProcessRunner/GitRunner seams, env sanitisation, output caps, timeouts, and `bwrap` / `sandbox-exec` wrappers where available. This is not container-level isolation.                                                                    |\n\nDesign direction that is not yet a runtime contract:\n\n- Named workflow modes such as `review`, `investigate`, `qa`, `ship`,\n  `security-audit`, and `design-review`.\n- Browser-backed QA evidence and design review.\n- Richer Agent Presets and preset workflows.\n- Broader context-window management and external memory provider selection.\n- A first-class workflow/runbook API if the v0 experiments prove valuable.\n\n## Quick Start\n\nChoose the path that matches how you want to run Hecate.\n\n| Path                        | Best for                                                                                                                                         |\n| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |\n| [Desktop app](#desktop-app) | macOS personal use on your laptop with optional embedded workspace terminal support. No Docker required. Linux/Windows bundles are experimental. |\n| [Docker](#docker)           | Local container, scripted local deploys, and the safer Linux/Windows alpha path today.                                                           |\n| [From source](#from-source) | Contributors and local development.                                                                                                              |\n\n### Desktop app\n\nDownload the current alpha from [hecate.sh](https://hecate.sh) or from the\nversioned GitHub Release assets below:\n\n\u003c!-- desktop-release-links:start --\u003e\n\n| Platform              | Bundle                                                                                                                                                                                                                                                                                 |\n| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| macOS (Apple Silicon) | [Hecate_0.3.0-alpha.1_aarch64.dmg](https://github.com/hecatehq/hecate/releases/download/v0.3.0-alpha.1/Hecate_0.3.0-alpha.1_aarch64.dmg)                                                                                                                                               |\n| Linux x86_64          | [Hecate_0.3.0-alpha.1_amd64.deb](https://github.com/hecatehq/hecate/releases/download/v0.3.0-alpha.1/Hecate_0.3.0-alpha.1_amd64.deb) or [Hecate_0.3.0-alpha.1_amd64.AppImage](https://github.com/hecatehq/hecate/releases/download/v0.3.0-alpha.1/Hecate_0.3.0-alpha.1_amd64.AppImage) |\n| Windows x86_64        | [Hecate_0.3.0-alpha.1_x64_en-US.msi](https://github.com/hecatehq/hecate/releases/download/v0.3.0-alpha.1/Hecate_0.3.0-alpha.1_x64_en-US.msi)                                                                                                                                           |\n\n\u003c!-- desktop-release-links:end --\u003e\n\nOpen the bundle and launch Hecate. The app starts the bundled runtime on a\nprivate loopback port, waits for it to become healthy, and opens the operator UI\nautomatically. State lives in the platform data dir:\n\n- macOS: `~/Library/Application Support/sh.hecate.app/`\n- Windows: `%APPDATA%\\sh.hecate.app\\`\n- Linux: `~/.local/share/sh.hecate.app/`\n\nmacOS release bundles are signed and notarized. Linux and Windows bundles are\npublished by CI but have not yet had the same manual launch coverage. The\ndesktop status, updater behavior, signing notes, and footguns live in\n[Desktop app](docs/operator/desktop-app.md).\n\n### Docker\n\n```bash\ndocker run --rm -p 127.0.0.1:8765:8765 -v hecate-data:/data \\\n  ghcr.io/hecatehq/hecate:0.3.0-alpha.1\n```\n\nOpen `http://127.0.0.1:8765`.\n\nThe container intentionally publishes only on `127.0.0.1`. If you bind it\nbeyond loopback, put your own access control, firewall, or reverse proxy in\nfront. See [Security](docs/operator/security.md) for the current threat model.\n\nPinned image tags, binary tarballs, checksums, compose examples, storage notes,\nand lost-token recovery live in [Deployment](docs/operator/deployment.md).\n\n### From source\n\n```bash\njust dev\n```\n\nLocal development requires Go, Bun, and the repo toolchain described in\n[Development](docs/contributor/development.md). First-run environment knobs live\nin [`.env.example`](.env.example).\n\n## Use The Console\n\n### Add a provider\n\nOn first boot, Chats is available immediately. If Hecate detects a local runtime\nsuch as Ollama or LM Studio, the first-run card can add it in one click. For\nmanual setup, open **Connections -\u003e Add provider**.\n\n![Chats first-run state with detected local providers and one-click setup](docs/screenshots/chat-empty.png)\n\nCloud providers need an API key. Local providers need a running local server\nURL, usually the preset default. Custom OpenAI-compatible endpoints can be added\nfrom the same modal when the preset catalog is not enough.\n\nAfter a provider is saved, Hecate discovers models and the Chats picker becomes\nroutable. The full provider catalog, env bootstrapping, custom-endpoint\nwalk-through, and credential rotation live in\n[Providers](docs/operator/providers.md).\n\n### Chat with or without tools\n\nHecate Chat keeps direct model turns and tools-on task-backed turns in one\ntranscript. Tools off sends through the gateway. Tools on uses the task runtime\nwith approvals, artifacts, sandbox policy, and traces.\n\n![Hecate Chat transcript with direct turns, task-backed turns, run links, trace links, and activity details](docs/screenshots/chat.png)\n\nIf the selected model cannot call tools, Hecate keeps the chat usable as direct\nmodel chat and makes the tools-unavailable state visible.\n\n![Hecate Chat with a selected model that cannot call tools, falling back to direct chat](docs/screenshots/chat-tools-fallback.png)\n\n### Review workspace changes\n\nWorkspace changes sit beside the chat as session context. You can inspect the\ncurrent Git diff, filter changed files, copy patches, and discard selected\nfiles without digging through transcript noise.\n\n![Chats workspace with the Workspace changes panel open, file tree filtering, and a rich per-file diff](docs/screenshots/chat-workspace-diff.png)\n\n### Supervise External Agents\n\nExternal Agent sessions run through local ACP-compatible CLIs. Hecate supervises\nthe session but does not proxy or pool those vendors' credentials.\n\n![Chats workspace with an external-agent file-write approval waiting for operator review](docs/screenshots/chat-agent-approval.png)\n\nApprovals surface as blocking operator prompts before gated actions can proceed.\n\n![Agent approval modal with ACP options, scope choices, and audit note](docs/screenshots/chat-agent-approval-modal.png)\n\nSee [Chat sessions](docs/runtime/chat-sessions.md), [Agent runtime](docs/runtime/agent-runtime.md),\nand [External Agents](docs/runtime/external-agents.md)\nfor the deeper contracts.\n\n## Project, Context, And Memory Flow\n\nThe newer Hecate shape starts with projects. A project is the durable local\nidentity for a work area: code, research, writing, design, ops, planning, or\nsupport. A project can start without a workspace; a workspace is the concrete\nfilesystem root used later by a chat, task, or external-agent session when local\nfiles matter.\n\nHecate ships the operator cockpit and runtime integration for this flow.\n[Cairnline](https://github.com/hecatehq/cairnline), embedded in the current\nruntime, is the agent-neutral authority for durable project, work, memory, and\nevidence coordination. Hecate owns runtime launch, model routing, approvals,\nsandboxing, traces, External Agent supervision, context snapshots, and the\nricher operator UI. A separately installed Cairnline connector may replace the\nembedded package boundary later without changing the Projects experience.\n\n![Projects workspace showing work queue, closeout checks, assignment evidence, and pending review](docs/screenshots/projects.png)\n\n```mermaid\nflowchart LR\n    Project[\"Project\u003cbr/\u003estable local identity\"] --\u003e Roots[\"Workspace roots\"]\n    Project --\u003e Sources[\"Project sources\u003cbr/\u003eURLs · notes · files · guidance\"]\n    Project --\u003e Memory[\"Project memory\u003cbr/\u003eoperator-approved entries\"]\n    Project --\u003e Work[\"Work items · assignments · handoffs\"]\n\n    Roots --\u003e Session[\"Chat · task · external-agent session\"]\n    Sources --\u003e Packet[\"Context packet snapshot\"]\n    Memory --\u003e Packet\n    Work --\u003e Packet\n    Session --\u003e Packet\n    Packet --\u003e Call[\"Model or adapter call\"]\n\n    Session --\u003e Artifacts[\"Artifacts · diffs · traces · reports\"]\n    Artifacts --\u003e Candidates[\"Memory candidates\"]\n    Candidates --\u003e Approval[\"Operator review\"]\n    Approval --\u003e Memory\n```\n\nImportant boundaries:\n\n- Context packets snapshot what Hecate assembled for a call. They are audit\n  evidence, not durable memory by themselves.\n- Project memory is explicit operator-approved context. Hecate does not write\n  memory automatically.\n- Project sources are provenance and source metadata first; Hecate does not\n  fetch source URLs or include source bodies unless a supported context policy\n  path explicitly does so.\n- Memory candidates can be proposed by chats, tasks, handoffs, or future\n  workflows. They stay out of context until the operator promotes them.\n- External-agent private memory stays outside Hecate unless the operator imports\n  or writes Hecate memory explicitly.\n\nRead the implemented contract in [Runtime API](docs/runtime/runtime-api.md#project-endpoints),\nthen the design records for [Projects](docs/design/accepted/projects.md),\n[Context assembly](docs/design/proposals/context-assembly-and-injection-boundaries.md),\n[Agent memory](docs/design/proposals/agent-memory.md), and\n[Workflow runbooks v0](docs/design/proposals/workflow-runbooks-v0.md).\n\n## Architecture And Docs\n\nThe full docs index lives at [docs/README.md](docs/README.md). Start with the\nbucket that matches your job.\n\n| You are...                         | Start here                                                                                                                                                                   |\n| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Running Hecate locally             | [Desktop app](docs/operator/desktop-app.md), [Deployment](docs/operator/deployment.md), [Security](docs/operator/security.md), [Providers](docs/operator/providers.md)       |\n| Calling Hecate from a client       | [Runtime API](docs/runtime/runtime-api.md), [Chat sessions](docs/runtime/chat-sessions.md), [Agent runtime](docs/runtime/agent-runtime.md), [Events](docs/runtime/events.md) |\n| Building coding-agent integrations | [External Agents](docs/runtime/external-agents.md), [MCP integration](docs/runtime/mcp.md), [Events](docs/runtime/events.md)                                                 |\n| Changing the codebase              | [Architecture](docs/contributor/architecture.md), [Development](docs/contributor/development.md), [Release](docs/contributor/release.md), [docs-ai](docs-ai/README.md)       |\n| Planning future runtime behavior   | [Design records](docs/design/README.md), especially the proposal/accepted/candidate bucket before implementation starts.                                                     |\n\nRuntime references:\n\n- [Runtime API](docs/runtime/runtime-api.md) - Hecate-native endpoints, task\n  lifecycle, approvals, streaming, projects, memory, work items, and handoffs.\n- [Agent runtime](docs/runtime/agent-runtime.md) - `agent_loop`, tools, costs,\n  retry-from-turn, stdout/stderr, and system prompt layers.\n- [Chat sessions](docs/runtime/chat-sessions.md) - transcript segments, direct\n  turns, task-backed turns, queued prompts, context packets, and External Agent\n  chats.\n- [Events](docs/runtime/events.md) - run-event names, payloads, and SSE replay.\n- [Telemetry](docs/runtime/telemetry.md) - OpenTelemetry spans, metrics, logs,\n  trace headers, local trace view, and retention.\n- [Sandbox](docs/runtime/sandbox.md) - subprocess boundaries, policy\n  validation, env sanitisation, output caps, timeouts, and OS wrappers.\n\nOperator guides:\n\n- [Providers](docs/operator/providers.md) - provider presets, custom endpoints,\n  credentials, model discovery, health, and circuit breaking.\n- [Security](docs/operator/security.md) - local-first threat model, workspace\n  safety, approvals, secrets, and advisory handling.\n- [Known limitations](docs/operator/known-limitations.md) - the plain-language\n  alpha boundary.\n\n## Status And Roadmap\n\nHecate is public-alpha software. The fastest-moving areas are supervised agent\nexecution, memory/context visibility, External Agent ergonomics, desktop\npackaging, workflow runbook experiments, and sandbox hardening.\n\nNear-term design direction:\n\n1. Keep embedded Cairnline as the portable Projects authority while Hecate\n   evolves as the operator cockpit and runtime/orchestration layer.\n2. Keep projects, context packets, memory, artifacts, approvals, and traces as\n   the shared substrate for all agent work.\n3. Prototype one report-only `qa` workflow using existing task runs before\n   adding a standalone workflow engine.\n4. Start browser support with conservative evidence capture and explicit state\n   isolation.\n5. Promote successful workflow lessons only as memory candidates with\n   provenance and operator approval.\n\nThe broader alpha-to-beta gate lives in\n[Beta roadmap](docs/contributor/beta-roadmap.md). Proposed, accepted,\ncandidate, implemented, and parked design records live in\n[Design records](docs/design/README.md).\n\n## Contributing\n\nSee [CONTRIBUTING.md](CONTRIBUTING.md). If you work with an AI assistant, start\nwith [AGENTS.md](AGENTS.md); the provider-neutral guidance layer lives in\n[docs-ai](docs-ai/README.md).\n\n## License\n\nMIT. See [LICENSE](LICENSE).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhecatehq%2Fhecate","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhecatehq%2Fhecate","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhecatehq%2Fhecate/lists"}