Skip to main content

igni

OpenSSF Scorecard

One spark ignites a team. An AI coding assistant built with Agno orchestration.

ignite-ember.sh

Inspired by Claude Code, igni is a terminal-based coding agent that assembles specialized AI teams on the fly. Describe your task — the Orchestrator picks the right agents, the right team mode, and runs them.

Why igni?

Claude Code uses a single agent loop — powerful but monolithic. igni takes a different approach: dynamic multi-agent orchestration. Instead of one agent doing everything, Agno's team system decomposes tasks, routes them to specialized agents, and synthesizes results — all automatically.

The numbers

Head-to-head benchmark on a 12-case software-engineering suite, 5 runs per system, deterministic grading. See docs/BENCHMARKS.md for the full breakdown.

igni (MiniMax-M2.7) + CodeIndex Claude Code (Opus-4.7)
Directly mergeable (✅) 49 / 60 (82 %) 31 / 60 (52 %)
Needs clarification (⚠) 4 / 60 (7 %) 22 / 60 (37 %)
Wrong target (❌) 7 / 60 (12 %) 7 / 60 (12 %)
Reproducibly correct cases (5/5 ✅) 8 of 12 3 of 12
Cost per run ~$0.05 $4.01
Wall time mean 2 331 s 1 548 s

igni wins by +18 ✅ trials at 1/80th the cost. The gap is concentrated in the ⚠ band — igni commits to a concrete answer where Claude Code stays in design-conversation mode. Both systems hit the same hard-wrong rate (12 %), so the win comes from converting partial/clarifying responses into directly-mergeable ones.

The architectural choices that drive the gap: (1) CodeIndex queried first, not files — a pre-built semantic + metadata index lets the agent locate reuse targets and conventions by typed filter or HyDE-style code-shaped query, instead of grep-walking the repo. (2) A mandatory "What already exists" preamble — agent must name the reuse target, the closest near-miss it rejected, and the conventions to match before writing any code. (3) A small, focused model with structured tools — MiniMax-M2.7 + index access matches Opus-4.7 quality at 1/80th the price.

Feature comparison

Feature Claude Code igni
Architecture Single agent loop Multi-agent teams (Agno)
Task routing Manual sub-agent spawning Automatic via Coordinate/Route modes
Code intelligence Grep + file reads Shell-first reads; CodeIndex semantic search as a licensed extension
Project knowledge None The Artifacts extension (licensed; its own Neo4j store), served through your igni server
Planning Plan mode (read-only) Agno reasoning + Tasks mode
IDE integration MCP server (stdio) None — igni ships the desktop app, the web client and the CLI; MCP client (Agno MCPTools)
Extensibility Plugins, hooks, MCP Agents + hooks + toolkits + MCP
Agent evals Not built-in Built-in regression testing framework
Memory File-based MEMORY.md Agno Memory + DB-backed storage
Learning None Agno LearningMachine (user profiles, entity memory)
Guardrails None PII detection, prompt injection, moderation
HITL Implicit Explicit confirmation/input requirements
Default model Anthropic Claude Whatever your igni server routes to, or your own (model-agnostic)

Quick Start

brew install ignite-ember/tap/igni-core  # or: pip install igni-core (the old name ignite-ember works for both)
cd your-project
igni --read-only -m "In one sentence, what does this project do?"

igni is the command; ignite-ember is kept as an alias so existing shell aliases and scripts keep working. Both are the same entry point, and pip and the Homebrew formula both install both names. On the command line it runs one task and exits (-m, or -p for a pipe); there is no terminal chat UI any more — run it bare and it says so.

What the published package holds today. igni-core on PyPI is v1.0.4, and it is this repository's build: the igni_core module, the igni command and the decisions service. The old name installs the same thing — pip install ignite-ember resolves to igni-core==1.0.4 through the alias (packages/ignite-ember/ — metadata, and a dependency on igni-core at the same version), and the Homebrew formula installs igni-core as well. The command above works either way. To work on it instead of installing it:

git clone https://github.com/ignite-ember/igni-core.git
cd igni-core
uv venv && uv pip install -e ".[dev]"
source .venv/bin/activate          # puts `igni` on your PATH

The interactive chat is the desktop app and the web client. A headless run cannot ask before it runs a command, so decide up front what it may do. igni reads files with the shell, which asks by default, so without --read-only the question above stops at its first cat with "Run paused for confirmation" and exits 1 — see A headless run cannot ask you anything.

To point it at your own igni server, set api_url in your user config, ~/.igni/config.yaml — not a project's .igni/config.yaml or config.local.yaml, which may not name a server and are ignored for it, with a warning — and run igni login (or igni login --token-stdin with a token). That writes ~/.igni/credentials.json, which igni -m and the desktop app both use. /login is not a shell subcommand: igni /login answers Error: No such command.

# ~/.igni/config.yaml
api_url: https://igni-api.acme.example
# Only when the portal (the sign-in page) is not on the API's origin,
# e.g. the API on :7777 and the portal on :3000:
portal_url: https://igni.acme.example

portal_url is worked out from api_url when both run under one name and differ by a host label (api.acme.example → acme.example); set it when they differ any other way, such as by port, or sign-in opens a page the API does not serve.

Or bring your own model (OpenAI, Anthropic, Groq, Ollama, etc.):

export OPENAI_API_KEY=sk-...
# .igni/config.yaml
models:
  default: gpt-4o
  registry:
    gpt-4o:
      provider: openai_like
      model_id: gpt-4o
      url: https://api.openai.com/v1
      api_key: sk-...              # direct key in config
      # api_key_env: OPENAI_API_KEY  # or from env var
      # api_key_cmd: "op read ..."   # or from shell command

See Quickstart for the full setup guide.

Quickstart (new setup)

  1. Install — pip install 'igni-core[decisions]==1.0.4' (or brew install ignite-ember/tap/igni-core; the old name ignite-ember installs the same package from either).
  2. Configure a model — set OPENAI_API_KEY (or any provider key) and add the model to .igni/config.yaml; or point api_url at your igni server and run igni login
  3. Run — igni -m "…", or the desktop app

See Quickstart for the full guide.

Upgrading

The VS Code and JetBrains extensions are no longer shipped or supported; release notes below that mention them are history.

The split release (v1.0.3 → v1.0.4)

  • igni-core is on PyPI. v1.0.4 is the first release published under igni's own name: pip install 'igni-core[decisions]==1.0.4' installs the igni_core module, the igni command and the decisions service. ignite-ember is now an alias — the same version, the same extras, nothing of its own — so pip install ignite-ember and the Homebrew formula install igni-core 1.0.4.
  • The cloud layer is its own package. igni-cloud holds the PostgreSQL storage and the producer/guest binding, found through the igni.layers and igni.storage entry points, rather than inside the core.
  • The wire contract is typed. The messages the backend and the app exchange have one definition, checked from both sides — the app's client is igni-core's contract, byte for byte.
  • One module per concern. The backend is split into modules that each own one thing — settings, auth, the cloud, the tools, the transport — behind interfaces the tests can substitute. Nothing reaches into another's internals.
  • igni login is a command. It opens the portal's sign-in page in a browser, takes the token back over a local callback, writes ~/.igni/credentials.json and hydrates the group pack. igni login --token-stdin does it without a browser.
  • The Windows sandbox is behind one interface. What it allows is one thing to state, and one thing to test.
  • An install made under the old name keeps working. The desktop app still reads the cache directory and the install marker under their old names until the next write, so an app installed before the rename does not reinstall its runtime.

Rebrand + signed desktop app (v0.7.0 → v0.7.1)

  • Rebrand to igni. Shorter, single-word product name — the Tauri window, the macOS Dock, the VSCode + JetBrains marketplace listings, the welcome screen, the agent's self-identification all read igni. Internal identifiers (PyPI package ignite-ember, Python module igni_core, Tauri bundle id sh.ignite-ember.desktop, VSCode/JetBrains plugin slugs) are preserved so existing installs keep auto-updating without breakage.
  • igni CLI alias. The terminal command is now igni (the old ignite-ember invocation still works for back-compat).
  • Apple Developer ID signing + notarization on the macOS desktop app. First-launch no longer triggers the "unidentified developer" Gatekeeper warning; the notarization ticket is stapled into the .app so offline first-launch works too. The auto-updater pulls a fully signed + notarized bundle.
  • Mermaid diagrams in the chat. Fenced ```mermaid blocks render as SVG (sequence / flowchart / state / ER / pie / gantt / mindmap / xy-chart / quadrant / timeline). Mermaid lazy-loads — first diagram in a session triggers the download.
  • Collapsible code blocks. Anything taller than ~220px starts collapsed behind a chevron with a fade overlay; click anywhere on the clip (or the chevron) to expand. Copy chip stays always-visible top-right.
  • GitHub-Light syntax colors on light theme. Stops the dark-dimmed highlight.js palette from painting neon-on-white when the user picks the light theme.
  • Per-turn stats restored on resumed conversations. Re-opening a session now shows the same ✦ in · think · out · duration pill the live path emits — chars/4 estimates pulled from each persisted run's content (Agno's raw input_tokens reads non-monotonic across iterations and was useless to restore literally).
  • Header drag-region fix. The first user message's edit / delete chip is no longer captured by the Tauri shell's window-drag region — clicks reach the buttons.
  • Updater signature bug fixed (v0.7.1). The macOS auto-updater's tarball-signature pair now matches at the asset level: stapled bytes are uploaded under the arch-suffixed name latest.json references, so signature verification succeeds. Anyone who installed v0.7.0 before this fix should update to v0.7.1 — the auto-updater itself will pull it through cleanly.

GUI clients (v0.6.0 → v0.6.4)

  • Tauri desktop app. Native window hosting the shared web UI; spawns the Python backend over a Unix socket, kills it on app exit (with IGNI_PARENT_PID watchdog for crash safety). macOS / Windows / Linux installers from CI; signed auto-updater backed by minisign.
  • VSCode extension. WebView hosting the same shared UI; activates on workspace open with one command. Auto-installs ignite-ember via uv on first run — zero-touch.
  • JetBrains plugin. JCEF panel hosting the same UI. Plugin SDK build wired into the release pipeline; published to the JetBrains Marketplace.
  • Shared web UI. clients/web is the single React+TS surface; the three shells embed it. Single bundle, single React tree, single CSS — visual + behavioral parity across the three hosts.
  • Backend multi-session reliability. SQLite hardening (WAL + checkpoint tuning), idle session eviction, slow-client back-pressure, sync-in-async call-site audit. Removes the long-running-session memory-leak class.
  • Release pipeline matured. Marketplace publishing for VSCode + JetBrains; signed Tauri updater via minisign; per-tag draft → publish flow that avoids race-y duplicate releases under parallel matrix uploads. Pre-release tags (-rc) skip marketplace pushes + Homebrew updates so iteration doesn't pollute user-facing channels.
  • UI polish (v0.6.1). Header / sidebar use a backdrop blur stack so messages frost as they scroll under; custom scroll-indicator thumbs (the native scrollbar would have rendered inside the blur layer); dark-theme icon variants.

v0.5.0 is the "Beat Claude Code" release. Cumulative changes since v0.3.8:

Benchmarks vs Claude Code (new in v0.5.0)

  • Head-to-head benchmark suite. 12 cases × 5 runs vs Claude Code on the same target codebase. Programmatic deterministic grading. igni wins 49 / 60 ✅ vs 31 / 60 ✅ at one-eightieth of the per-run cost. Full breakdown in docs/BENCHMARKS.md.
  • CodeIndex-first specialist agents. New *.codeindex.md variants for architect, debugger, explorer, reviewer, security, simplifier — each with prompts tuned to query the index first instead of grepping. Auto-selected when a populated CodeIndex exists for the current commit.
  • Mandatory "What already exists" preamble. The main-agent prompt now requires every code-write response to start with a four-bullet section naming (a) the reuse target, (b) the closest near-miss it considered and rejected, (c) the conventions to match, (d) the parallel infrastructure it will not introduce. Forces contrastive reasoning before code is written.
  • Encapsulation rule. When a service class wraps a resource (db client, cache, queue, storage), new code must call methods on that class instead of inlining the raw client. Catches the "copy a private prefix into a new file and instantiate the client myself" anti-pattern.

Plan-and-Align workflow (v0.4.2)

  • HITL approval for complex action work. Main agent now plans first and waits for user approval before executing non-trivial tasks. Read-only review/audit work bypasses this and goes direct to the agent loop.
  • "Working with the User" framing. Prompt restructured around "the human owns the bigger picture" — agent surfaces trade-offs, asks when uncertain, takes pushback seriously instead of defending its plan.
  • Strengthened safety rules. Explicit handling for .env files, raw SQL, destructive shell commands, and blind-edit prevention.
  • Eval framework rebuilt. Per-case Session isolation, per-case timeout overrides, tool_arg_assertions (e.g. asserts spawn_team(mode="...")), prior_messages for multi-turn cases, work-dir-aware file assertions. New eval suites for bulk_edits, file_safety, mcp, team_modes, team_tasks, knowledge_corner, knowledge_proactive, memory_knowledge, multiturn, error_recovery, long_running, schedule, web_discipline, background_notifications.

Async shell + background notifications (v0.4.1)

  • Pure async shell tool. run_shell_command / read_process_output / watch_process / stop_process / list_processes are now async def using asyncio.create_subprocess_exec. Previously blocked the event loop for up to the timeout (and a hard 3s on every background=True call), starving the HITL multiplexer drain and the FE message stream.
  • Background-process completion notifications. When a backgrounded shell command finishes, the agent receives a queued BACKGROUND PROCESS COMPLETED notice with the output tail; the TUI also gets a PushNotification.
  • Idempotent read_process_output. Multiple reads with different tails work; eviction moved to a 10-min TTL after the most recent read.
  • Schedule eval suite. 12-case suite verifies the agent reaches for Schedule exactly when the user describes deferred/recurring work — and not otherwise. Achieves 12/12.

Sub-agent HITL + run resumption (v0.4.0)

  • Sub-agent HITL bridge. Specialist sub-agents (e.g. architect) can now request user confirmation through the same TUI flow as the main agent. Multiplexer was extracted from run_message and resolve_hitl so parent pauses no longer drop the specialist's pause requirements.
  • acontinue_run "No runs found" fix. Session DB is now threaded into pool specialists and the Team(...) constructor so paused runs are persisted and can be resumed.
  • Concurrent-spawn race fix. Per-spawn copy.copy() of pool specialists in spawn_agent / spawn_team. Without this, two concurrent spawns of the same specialist raced on shared Agent per-run state and Agno errored with "No runs found for run ID".
  • BE/TUI cleanup robustness. Signal handlers, atexit, process-group kill, and an IGNI_PARENT_PID watchdog. Closes the runaway-BE failure mode where the TUI crash left a zombie backend.
  • httpx timeout actually applied. Was previously shadowed by the SDK timeout when an http_client was provided.
  • Eval harness. Auto-approve HITL drain, --case-timeout (default 60 s), --case-retries (default 2), --spawn-timeout, retries=0 for determinism, WebSearch stub, ENV vs FAIL output classification, default concurrency 5.
  • New tests. test_subagent_hitl_e2e (8 cases, bridge in isolation), test_orchestrate_real_agno (real Agno Agent + AsyncSqliteDb).
  • 1363 tests pass.

Earlier v0.3.x fixes still relevant

v0.3.8 includes the following changes:

  • Problem: Escape key did not close the MCP panel (/mcp) or the task panel.
    • Solution: Added all dialog/panel widgets to the Escape handler, including MCPPanelWidget and TaskPanel.

v0.3.7 includes the following changes:

  • Problem: Edit/Write/Bash tools never asked for user confirmation, even when permissions were set to "ask".
    • Solution: requires_confirmation flag is now set on each function after registration in all custom toolkits.

v0.3.6 includes the following changes:

  • Problem: Debug logs grow unbounded and can fill up disk space.

    • Solution: Switched to RotatingFileHandler with 10MB limit and 2 backup files.
  • Problem: Shell command output can be extremely large, causing issues when sending to the LLM.

    • Solution: Truncate tool results to 30,000 characters, keeping start and end of output.
  • Problem: TUI escape key only closes the login dialog, leaving other panels open.

    • Solution: Now closes any open panel: login, help, model picker, or session picker.
  • Problem: Learning features get stuck and never complete (caused by httpx connection pool issues in threads).

    • Solution: Run learning extraction as an async task on the main event loop instead of a separate thread.

To upgrade igni to the latest version:

brew upgrade ignite-ember/tap/igni-core

If brew upgrade doesn't work or you encounter issues, manually reinstall:

brew uninstall igni-core && brew untap ignite-ember/tap && brew tap ignite-ember/tap && brew install igni-core

Clients

The Textual terminal UI was removed in v0.9.7, and the VS Code and JetBrains extensions are no longer shipped. igni ships the desktop app (Tauri), the web client and the CLI. The desktop app and the web client share one web UI, both in igni-app; the desktop app spawns the backend and talks to it over a WebSocket (python -m igni_core.backend --ws-port 0). Features: streaming responses, agent tree visualization, token tracking, session picker, keyboard shortcuts, HITL confirmation dialogs. In a terminal, igni -m and igni -p run one task.

MCP

igni acts as an MCP client: configure external MCP servers via /mcp or the MCP panel and their tools become available to the agent.

Exposing igni itself as an MCP server (so any MCP-compatible IDE — Cursor, Windsurf, etc. — can connect to it) is on the roadmap; the igni mcp serve subcommand isn't shipped yet.

Key Features

Project knowledge

There is no knowledge base in igni itself any more: the knowledge: settings and /knowledge commands left with the Artifacts module, a separate licensed service that keeps project documents and decisions in its own Neo4j store and ships its extension through your igni server. A super admin approves the service once; signed-in people get its tools.

Learning & Reasoning

  • Learning — Agno LearningMachine builds user profiles, entity memory, and session context across conversations
  • Reasoning tools — think and analyze tools for step-by-step reasoning during complex tasks

Guardrails

Built-in safety guardrails via Agno's pre-hook system:

guardrails:
  pii_detection: true          # detect and flag PII in prompts
  prompt_injection: true       # detect injection attempts
  moderation: true             # OpenAI moderation API

Human-in-the-Loop (HITL)

Agents can pause execution to request confirmation or user input before proceeding with sensitive operations. The desktop app and the web client show interactive approval dialogs; a headless igni -m cannot, so it follows the permission policy and stops at anything only a person could approve.

Documentation

  • Quickstart — Get up and running in under 5 minutes
  • Architecture — System design and agent topology
  • Agents — Specialized agents and their roles
  • Skills — Reusable prompted workflows (/deploy, /resolve-issues, etc.)
  • Onboarding — First-run setup, CodeIndex, and agent proposals
  • Tools — Available toolkits and capabilities
  • MCP — IDE integration via Model Context Protocol
  • Configuration — Settings, permissions, and customization
  • CodeIndex — semantic code intelligence engine; an extension, documented in the CodeIndex repository (igni__code-index/docs/igni-integration.md)
  • Benchmarks — Head-to-head comparison vs Claude Code on a 12-case suite
  • Evals — Agent evaluation framework and regression testing
  • Hooks — Pre/post tool execution hooks
  • Extensibility Floor — The contract extensions build against, and what it guarantees them
  • Platform Plan — What has to be built for the single-user and shared backends, in order
  • UI package — The tokens, classes and components an extension builds against (in igni-sdk)
  • Design System — The scales, the primitives, and what still needs a human eye (in igni-app)
  • Build Plan — The same work as ordered items, with the files they touch and how each one is verified
  • Migration — Coming from Claude Code or Codex
  • Security — Threat model, permissions, and enterprise hardening
  • Reporting a vulnerability — where to send it, and what happens next
  • Verifying a release — checksums, SBOMs, build provenance and signatures, online and air-gapped
  • Vulnerability management — what is scanned, what gates, and the remediation targets
  • Development — Contributing and extending igni

License

Apache 2.0 — see LICENSE and NOTICE.

Metadata

Release files for igni-core 1.0.4

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for igni-core 1.0.4
File Size Uploaded Provenance Actions
igni_core-1.0.4.tar.gz 4.6 MB With provenance Details for igni_core-1.0.4.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for igni-core 1.0.4
File Interpreter ABI Platform Actions
igni_core-1.0.4-py3-none-any.whl Python 3 none any Details for igni_core-1.0.4-py3-none-any.whl

Total release size: 7.0 MB

Release files / igni_core-1.0.4.tar.gz

Download URL igni_core-1.0.4.tar.gz
Size 4.6 MB
Tags Source
SHA-256 checksum
How to use checksums
92921412d02ff30fb2a934d4460882b9b5dd13d33ae0d75307e30b8665434269
BLAKE2b-256 checksum
How to use checksums
ea248a44eb66f592359d85b64aa956f714dd044512bab0b221c527a851cc57a4
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Release files / igni_core-1.0.4-py3-none-any.whl

Download URL igni_core-1.0.4-py3-none-any.whl
Size 2.4 MB
Tags Python 3
SHA-256 checksum
How to use checksums
357a711119281aa191f15aef0cdc8f6e2439fe41bc185fd3fe210f52cbd14dc3
BLAKE2b-256 checksum
How to use checksums
18284093cd38d49ac0f63216decb2a644bdb72f22f32649c07535ae0c49051a3
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

Security for igni-core 1.0.4

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

Both files in this release have been uploaded with provenance metadata.

Select from 2 files

Attestation for igni_core-1.0.4.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 15, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

1.0.4 This release

2 release files Full provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page