What you can do with Codelux AI

Fixes

• Agents read the right rules — the Codelux block written into AGENTS.md and CLAUDE.md is rewritten for 4.13 at the next session start: brief, claims, plan, documents, decisions with supersede and retract, traps by symbol name, report {vote, notes}.
• Plan proposals only from work orders — a question or a chat line no longer creates a task; one proposal per session; proposals born from questions are retired with a trace. Switch planner_auto_propose.
• Timeline — a session open for days appears on every day it worked, with "started on".
• No console windows on Windows when the app runs git, p4 or sail; sub-agent names and update notes verified UTF-8 end to end.

What is new

• Timeline 3 — one page with everything: day → main session → sub-agents → every step (brief, reads with re-reads, searches, commands with their outcome, edits with claim status, documents released, git commits, diary, decisions, traps, plan, claims, conflicts, alerts, reminders, provider, system). Three views: Tree, Time, Categories. Click a node: the right pane shows the diff, the file at the line, the document, the command, the memory entry or the task; "Open in …" goes to the full page. A System node with daemon starts, indexing, connect, cache restarts, conflicts and measured disk space.
• Plan that measures reality — M (manager) and U (user/agent) are plans; R is measured by Codelux from the sessions' trace: work and pauses, growing while the agent works. An agent links its session to a task (or Codelux proposes one to confirm), sends messages and % to the plan, records variations with a flag; the U plan keeps a dated history with reasons; the manager's plan is never touched by agents.
• Agenda — personal appointments with repeats and reminders in the bell (Done / Snooze), a diary per day; local only.
• Providers connect themselves — one consent, then Codelux connects Claude Code, Codex, Gemini and Cursor and keeps them aligned; every action is in the Timeline; a provider is "ready" only when its hooks really arrive.
• Sub-agents show their own model, never the parent's; claims survive restarts and warn the second live agent; hook rows and Codelux calls of the same agent are one agent, also after a restart of the app.
• Main pages — under Overview a pinned section (Timeline, Plan, Agents now, Notes by default); the pencil next to the project name lets you choose and order them.
• Fresh start — codelux archive (and the button in Settings) moves a project's work and history into a dated archive, keeping memory, index and team data: a clean measurement week can start.

What is new

• codelux connect — no plugin store needed: Codelux detects the AI tools you use (on this computer, in the project, in the trace) and writes its MCP server, hooks and skills into their own config files, with a dated backup and without touching your other settings. It keeps them aligned at every update and removes exactly what it wrote. Panel "Collegamento ai provider" in Settings, when you add a project and once per version.
• Alerts — the bell is now the alerts centre of all projects: hooks not active, provider used but not connected, anonymous agent, token or cost caps, licence, two agents on the same file, memory to review, errors. A dot on the project in the sidebar, an "Avvisi" page under Work, snooze for 7 days. A provider is green only when its hooks actually arrive.
• Ask the AI — in Help: a dialog prefilled with the current page; the AI tool you already use answers with the whole Codelux help as context.
• Claims — survive a restart, warn the second live agent and notify the claim holder, glob patterns stay narrow, no noise for your own edits.
• The app as a Windows service connects your tools in your user folder, not the system one.

A new shape

• One tree — every project is now organised in four roots: Work (plan, agents right now, file claims, checkpoints), Project (documents, current decisions, traps, code maps), History (per day and per agent, reports) and Code (search, outline, git, files). The same tree is the brief an agent receives.
• Memory never stores paths — traps and code maps name symbols and words; the index resolves where the code is at read time (✓ found, ≈ by words, ⚠ not found). Nothing goes stale when you split, move or rename files; certified code points, recertification and restructure are gone.
• Corrections at zero risk — every entry shows who wrote it and when; correcting means adding (supersede or retract with a reason), never rewriting; conflicting decisions are flagged, entries nobody reads for 60 days leave the brief but stay searchable; nothing is ever deleted.
• Reports written by Codelux — at the end of every session and sub-agent: steps through Codelux and direct, files read and re-read, commands, tokens and cost per provider, tasks, claims, conflicts. Only measured numbers; the agent adds a vote and notes. Weekly report per project and per team.
• Briefs within budget — sub-agents get their brief in about two seconds; hooks never block an agent; the app shows whether hooks are active.
• Lighter — micro-apps, dead routes and two unused tools removed; about nine thousand lines less.
• One-off migration of existing memory: codelux memory migrate --dry-run, then without.

For every developer

• Briefs with the code inside — at start an agent receives the functions its task touches, verified by hash, plus a one-line index of every file it cites, so it reads ranges instead of whole files. Briefs build in about a second, also for sub-agents.
• Documents — a document per topic with fixed sections (summary, rules, decisions, traps, files, flow); agents update one section at a time, every change is versioned, the index is generated.
• Memory that checks itself — facts and traps anchored to code are re-checked at every indexing: moved code is followed, changed code marks the entry "to review" and keeps it out of briefs.
• File claims that speak — an agent editing a file another agent claimed gets a warning; the claim holder is notified, also when the file changes outside the editor.
• Search — searching a file path lists its symbols with line ranges; journal records (decisions, documents) are searchable; outlines carry declaration ranges.
• Downloads never stop the running app — a new build takes over at its first start; the old one keeps working for two hours with a notice.
• Console: the download row only starts the download; progress lives in the header icon. Timeline: a session no longer ends when the desktop app restarts.

For every developer

• Full agent trace — every tool your AI agents use (read, edit, run, search) is recorded through the plugin hooks, with paths, hashes and line ranges, never the file text. See it in the new Procedure view.
• One identity per agent — the same agent has the same name in hooks, MCP, REST and CLI, sub-agents included.
• Memory that follows your code — when you split, move or rename files, Codelux recognises moved code: certified code points and code maps point to the file where the code lives now. A restructure command forces the update after a big split.
• Better memory for agents — decisions can replace older ones (only current ones are shown), wrong entries can be retracted, sub-agents get a brief at start, injected memory is more relevant and does not repeat, saves are queued when the app is down.
• Code map — your own maps are added and edited in a dialog.
• The app as a Windows or Linux service now reads your agents' data from your user folder, so Usage keeps working.

For teams

• A personal key for every member — the owner keeps the master key; each member receives only a personal key, and the team keys arrive in an envelope sealed by the owner's app. Removing a member blocks them at once and rotates the keys in seconds, with nothing to do for the others.
• Managers read their team — Standup and Costs of their team in the console, with their personal key.
• Faster, reliable real time — no lost events, quicker reconnects, and a clear warning when an edit could not take the team lock.

For every developer

• A simpler app — Overview, Timeline, Planner, Usage, Team, Code, Memory, Audit, Settings. The Activity page and the Beta pages are gone: everything they showed is in the Timeline and in Usage.
• Planner with your agents — agents read your open tasks at session start, take them, report progress and propose them as done; you confirm. In a team the manager assigns and sends the planning, members confirm or send back with a reason; every step is in the Timeline.
• Usage you can act on — one chart per provider for today, 7 days or your plan month, with the warning and maximum lines; plans and daily caps are set in the Console, for Multi and Team.
• Settings cleaned up — no more approvals gates: agents build, verify and push on their own; the Teams page is informative only; the AI providers page is gone.
• Git folder — a project whose repository lives in a subfolder can point Codelux to it.

For every developer

• Updates, announced in the app — Settings › Updates lists what is new: the interface, its languages, terms to accept and new versions of the app. Interface and language updates install by themselves after a signature check, or only when you press Update if you prefer; if anything goes wrong, the version you have stays in place.
• Your language — the app speaks English, Italian, German, French, Spanish and Portuguese; the console and the website speak English and Italian. A corrected translation now reaches you on its own, without reinstalling anything.
• A new Timeline — every change in one plain sentence: who made it, which agent, what changed, with the diff one click away.
• Documentation instead of the guided help — the help panels and the tour inside the app are gone; the documentation on codelux.ai explains every page and every tool, always up to date.

For teams with their own hub

• Updates, announced in the console — Settings › Updates shows a new console, a language correction or a new hub version. The console follows your update policy (automatic, pinned or manual); a new hub version comes with step-by-step instructions, and your server is never replaced without you.

For every developer

• A new Timeline — every event in one plain sentence: who (you, a teammate, Claude Code, Codex, Git), the agent's id, what changed; one click on the arrow opens the changes on the right, notes included.
• Sessions and cache — the Timeline tells when an agent started, resumed from Codelux memory, restarted from zero after a long pause, and how much of the work the provider's cache covered.
• Your language everywhere — the language is now part of your account and follows you in the app, the console and the website, among the languages each one offers.
• Translated app — the remaining English texts of the app are now translated in all six languages.

For every developer

• A clearer menu — Overview on top, then Work, Agents (Activity and Usage), Team, Tools and Audit; the index setup moved into Settings.
• Usage you can read — tokens and estimated cost by day, project, session, model and agent, with the cache detail; how each session used Codelux; an observed comparison of your resumed sessions with and without Codelux memory.
• Overview — the last 4 hours of agent activity; from any Timeline event, one click to the matching Activity.
• Your settings stay — theme, language and sidebar layout are kept by Codelux, not only by the browser.
• Fixes — the code editor opens again; Files can show ignored and excluded files; the project ring shows a moving dot when the total is not known yet; the web Console signs you in without extra clicks when you are signed in on codelux.ai.

For every developer

• Live indexing progress — the Overview shows files done and total, the file being indexed, the phase and the time left; the project circle in the sidebar shows a progress ring.
• Start, pause, resume, stop — indexing controls on the Index scope page and in the Overview; Codelux keeps answering while indexing is paused.
• Last 4 hours — a new Overview panel with the recent activity of the project.
• Fixes — narrowing the index scope now removes the excluded files in seconds; progress no longer jumps between projects; the Teams page appears only to Team plans and team members.

For every developer

• Memory as proof — what Codelux remembers about your code is now a set of code points, each certified by a hash of the code itself. When an agent resumes, every point is checked against the files as they are today, so it can trust what is still true instead of re-reading the project.
• Points that stay up to date — when an agent edits code through Codelux, the affected code points are saved again right away. The other sessions open on the same project get a notice, and in a team the updated points travel to your teammates' machines.
• A better start for every session — the memory injected when a session starts depends on how it starts (new, resumed or compacted) and on whether the prompt cache is still warm, so a cold start gets what it needs and a warm one is not padded.
• AGENTS.md for Claude Code — the project's AGENTS.md is read by Claude Code through an import in CLAUDE.md, so every agent follows the same project rules.
• Fixes — the session-end hook is no longer cancelled before it finishes, so the last events of a session are saved; the Timeline prints times in your local time.

For every developer

• The Console — one place on codelux.ai for your account: plans and checkout, AI assistance top-ups, invoices, devices, sign-in methods and your data.
• AI assistance — ask the assistant how Codelux works; it answers from the product map of this very version and can show you where to click.
• Memory and timeline across agents — what each agent learned and did stays in your project, readable by the next one, whichever agent it is.

For teams and companies

• Three roles — Admin, Manager and Member, set per team. Admins run the organization, Managers run their teams from the app, Members work.
• One Console for the organization — billing, plans and invoices, and single sign-on (OIDC or SAML) and SCIM provisioning, set up by the owner and the organization admins.
• Manager — tasks as a list, a board and a Gantt chart, standups built from the timeline and never from the chat, members, and exports.
• Company hub with connectors — codelux-hub, run by your company, with Jira, Linear, Asana, Azure Boards, GitHub and GitLab, and Slack notifications. Your tokens stay on your hub.

For teams and companies

• Three roles — Admin, Manager and Member. Admins create teams and assign each person as Manager or Member of each team.
• Projects grouped by role — your personal projects, then the teams you are a member of, then the teams you manage, with a Manager workspace for each team you run.
• Company hub — codelux-hub, included with Team and run by your company: register it and download it from the Console.
• Connectors on the hub — Jira, Linear, Asana, Azure Boards, GitHub and GitLab, and Slack notifications for confirmed standups and finished tasks. The hub runs them; our server has no connector and never holds your tokens.

For every developer

• Usage — on every plan: your AI usage read from the counts your agents already write on your machine (numbers only, never the conversation), with cost, plan fit and limit hits.
• My plan — your own tasks, which stay on this computer.

For teams

• Team plan — the tasks the team assigns, next to your own.
• Timeline: Who — filter the timeline by person, with an Agent filter, to see what each member and each of their agents did.
• Approve a web console from the app — the app shows the browser that asks for the team key, and you approve it with the code it displays (for company hubs).

For every developer

• Sign in with Google or GitHub — no password to remember.

For teams and companies

• Manager — owners and admins of a team project get tasks as a list, a board and a Gantt chart, standups built from the timeline (never from the chat), members, and a per-member export. Each standup report is encrypted for the owner, the admins and the member it is about only.
• AI usage and costs — Codelux reads the usage counts your agents already write on your machine (Claude Code, Codex, Gemini CLI; numbers only, never the conversation), and the Manager shows real cost from plans, volume, plan fit, limit hits and a budget per project.
• Single sign-on — OIDC or SAML for your company, SCIM deprovisioning and organization admins.
• Team key recovery kit — when a team key is created or rotated, the owner saves a recovery kit before members receive the key.
• Security pack — the DPA template and the security questionnaire, free to download from the Security page.

For every developer

• Export the timeline — from the Timeline: what you see, with your filters, or everything, as JSON or CSV.
• Exports are recorded — every export appears in the timeline, so the audit is audited too.

For teams

• Team audit — owners and admins download a ZIP with members and roles, projects, the full timeline of every team project, memories, notes with their history, code maps, checkpoints and the lock history. It is built by your app on your machine, because team data is end-to-end encrypted and our server cannot read it. The team chat is not included.

For every developer

• Memory written by your agent — at the end of a task the agent saves one memory with memory_set: what it did, why, the next step, the traps, facts anchored to file and line, code maps. Codelux files the known parts as checkpoints, decisions, facts, todos and code maps; memory_get brings it back the next day.
• Timeline — everything that happens on the project, in order: memories, notes, todos, forms, code maps, file edits, Git commits, locks, messages between agents. Click a row to open it in place; filter by type, topic, person or agent, and period.
• Notes for people — notes, todo lists with checklists, forms the agent writes and you fill in, diagrams.
• Many agents, one file at a time — a file semaphore between agents: the first to take a file writes, the others are told who holds it and wait. Every lock, refusal and edit shows in the timeline.
• Claude Code plugin with hooks — the project memory arrives by itself at session start and, when relevant, with each prompt; the lock is taken around Claude Code's own edits; a reminder to save a memory at the end. Codelux also keeps a short memory block up to date in AGENTS.md (and CLAUDE.md when present), inside its own markers.
• Eight tools — memory_set, memory_get, notes_set, notes_get, code_query, code_context, code_edit, agents_msg. Your agent keeps its own search, reading, editing and Git; every other Codelux tool stays available with /mcp?profile=full.
• Projects from the app — add, rename, change folder and remove projects, with a folder picker; moving a project keeps its history.

For teams

• Shared memory — memories and timeline events are shared with your teammates, end-to-end encrypted like notes and code maps.
• Across machines — the file semaphore works across machines on the Team plan.

What you can do

• Compact tool descriptions — every tool is described in one or two sentences; the full guide of a tool, with formats and examples, is one call away with code_help and a tool name.
• A core tool set over HTTP — http://localhost:8766/mcp lists the search, read and memory tools; add ?profile=full for the write and Git tools (the Claude Code plugin does). Every tool stays callable by name either way.
• Answers grouped by file — code_grep and code_tree group hits by file and show real code before tests; code_query, code_outline and code_context give one line per symbol.
• Memory on request — the recent-activity line is added to code_query and code_grep only when you ask for it (with_memory).

What you can do

• Native Go parsing — Go files are read with the Go compiler's own parser.
• Instant re-index — unchanged files are skipped by size and modification time without being read.
• New projects index themselves — a project added on the website is picked up and indexed by the running app, with no restart and no command.
• The real definition first — code_query ranks the definition of a symbol before the tests that call it, and understands Group() with parentheses.

For teams

• Team plan, zero-knowledge — one shared project per team, run from the site. The team key is generated in the owner's app and handed to members by you, or machine to machine in a sealed envelope. Our server stores only encrypted events and never holds the key: shared data is unreadable for us too.
• Chat in channels — a team channel, direct messages and groups, all encrypted with the team key.
• Git clones or a shared folder — the admin chooses per team how files are shared: everyone on their own clone, or everyone on the same files (a network share, Dropbox, OneDrive) with the lock held until the cloud sync lands.
• Who is editing what — cooperative file locks and online presence; writes to a shared project are refused while the service is unreachable, never applied blindly.
• Team build for covered members — a member whose seat is paid by the owner downloads the Team build and works on the shared project; their own projects stay on Free.
• Authors on shared knowledge — notes, journal, facts and codemap entries carry who wrote them, with an All / Me / member filter.
• Key rotation — rotate the team key from the site; the owner's app creates the next version and delivers it.

For every developer

• A public Free build — download without an account and sign up inside the app: one active project per machine, every tool, no time limit.
• One Codelux per machine — sign in with the same account elsewhere and that machine takes over.
• Plan badges — the app shows your plan and, on shared projects, the team's share mode.

Notes

• Block diagrams — draw a flow instead of writing it: drag rectangles, add a diamond for a decision, connect them with labelled arrows. Stored as plain JSON and drawn with no external library, so it works with no network at all.
• Checklists you create — make a todo from the app, one item per line, and tick the items off as you go.
• One editor per format — every note format opens its own editor, in the page and in the dialog.
• Notes grouped by last change — bucket the list by the day of the last edit (Today, Yesterday, date), not only by creation.

AI providers

• Providers in Account — register a provider once, list its models and switch each one on or off. Keys are sealed to your machine and never returned by the API.

What you can do

• Codemaps from checkpoints — closing a checkpoint on a topic adds every file it touches to that topic's codemap and drops files that no longer exist: no stale paths, no manual upkeep.

Continuation protocol

• Checkpoints — close a session with what is done, what is open, the traps and the next step; the next agent, or the next session, reads it back in one call.
• Delta detection — a checkpoint remembers the state of the files it touched, so a new session is told what changed since, and a hand-off is never trusted blindly.
• Any text file — docs, HTML and configuration are compared too, not only source code.
• Topic timelines — checkpoints are grouped under dotted topics such as Editor.Move; asking for Editor shows everything beneath it.
• MCP, command line and HTTP — codelux_set, codelux_get, and the matching codelux set / codelux get; deleting a journal record never touches a project file.

In the app

• Journal — browse topics as a tree, with the latest checkpoint, the files changed since, and the timeline of decisions and edits for that area.

For every developer

• Brief — ask what Codelux already knows about a task and get a ready answer: relevant facts, symbols and recent edits in a single call.
• Facts — everything Codelux has learned about your project, each fact flagged fresh or "to recheck" as soon as the underlying code changes.
• Smarter codemaps — Codelux pins a codemap by itself after working through a recurring group of files.

For teams

• Self-releasing locks — a file lock is released on its own if the teammate holding it goes offline.

What you can do

• Cooperative writes everywhere — lease-based file writes on MCP, HTTP and the command line, so agents without MCP and plain scripts can coordinate too.
• Note history — every edit to a note is kept with its diff: who changed what, and when, right in the notes list.

For every developer

• Local agent leases — several AI agents, sub-agents or worktrees on the same machine take a lease on a file before editing it; works on every plan.

For teams

• Solo or Team mode — the admin sets the mode per project; Team turns file locking on for everyone with no local configuration.
• Cooperative file locking — an agent or a teammate leases a file before editing (short lease, renewed automatically, released if forgotten), so two people never overwrite each other.
• Across machines — on Team plans the lease is backed by a realtime service, so people and agents on different computers are coordinated on the same file.
• Project members — the admin invites teammates per project; members only see the projects they have been added to.
• A shared live space — presence and who is editing what, synced across every connected teammate and agent.
• Git hooks — commits and pushes on Git-remote projects release the matching locks.

What you can do

• Vue and Razor — symbols are extracted from Vue single-file components and Razor views.
• Quicker codemaps — jump back to a pinned work area from the sidebar.

Cross-session memory

• Memory timeline — a compact timeline of recent notes, file edits and tool calls, a plain read with no model call. Filter by time window, keyword and kind. Your AI reads it first thing in a new session.
• Typed notes — notes that survive across sessions: intent, decision (and why), todo with a checklist, summary, schema, HTML, form, chat, research, snippet — each with its format and optional file anchors.

Exploration sessions

• Explicit exploration tracking — start, step and end an exploration; each start brings back the most similar past sessions so the AI can follow a known path.
• Recall — look up past sessions that match an intent.

Codemaps

• Named work areas — create, list and open $key shortcuts (label, files, symbols); search matches their labels so a codemap floats to the top of the results.

Core

• Smart Query — boolean search (& / | / !) with fuzzy matching on name, intent, docs and semantic domains.
• Flow analysis — recursive call trees with cycle detection and external-call markers.
• Live reindex — changed files are indexed again while you work.
• Line-accurate reading — compact symbol data and file reading that keeps the original line numbers.

Integrations

• MCP server — over SSE at localhost:8766/sse; works with Claude Code, Cursor, VS Code, Windsurf, JetBrains, Zed and any MCP client.
• REST API — every tool as an HTTP endpoint for scripts, CI and your own tools.
• Web interface — a multi-project sidebar, web sign-in and a UI in six languages.

Memory

• Knowledge graph — keywords, files and symbols linked by how they are really used, built with every query.
• Session memory — searches are recorded per session; a new session recalls what similar ones already found.
• Worker AI (optional) — semantic clustering and graph enrichment with your own OpenRouter, Anthropic or OpenAI key.

Local first

• Your code stays on your machine — the index is encrypted with AES-256-GCM and bound to your hardware.
• Signed binary — a personalised build for your account.

What you can do

• Codemaps — pin a work area to a named $key and return to it instantly.
• One tree view — the callers and the callees of a symbol in a single answer.
• Watch Difference — a built-in change history with inline diffs, independent of Git.

Search and graph

• Semantic domains — group symbols by domain (auth, payment, iot, ai…) and search by intent.
• Knowledge graph — keywords, files and symbols linked by how they are really used.
• Per-query recall — the files and symbols most relevant to what you searched before come first.

What you can do

• Background AI enrichment (beta) — semantic clustering and graph enrichment on a timer, with your own OpenRouter, Anthropic or OpenAI key.
• Notes — typed notes that carry over between sessions: intent, decision, todo.

What you can do

• Recursive call trees — follow a call down through your code, with cycle detection and markers for external calls.
• Git in the interface — browse commits, branches and diffs next to the code.

What you can do

• Many languages — accurate symbol extraction with Tree-sitter across more than twenty languages.
• A web interface — a multi-project sidebar, web sign-in and a UI in six languages.
• Live reindex — a file watcher keeps the index current while you edit.

Reading code

• Compact symbol index — the symbols of your project in a form your AI can scan quickly.
• Line-accurate file reading — read any file with its original line numbers, so every answer can point at an exact line.

API and automation

• REST API — every tool exposed as an HTTP endpoint, for scripts and CI.
• Incremental indexing — only the files that changed are read again.

What you can do

• Index your code — a symbol index of your project, built on your machine.
• Query it over MCP — your AI asks Codelux for the code it needs, through the first Codelux tool.
• Stay local — everything runs on your computer.