SYNAPTIC Expert

AI-assisted development for engineers who care about traceability. Decision Gates, project memory, audit trail — and your choice of provider.

Most AI coding tools answer your prompt and forget. SYNAPTIC Expert remembers what you've decided, validates how it responds, and leaves an audit trail you can defend later.

Built for three kinds of users:

• Developers who want higher-quality output without manually re-prompting the model after every weak answer.
• Technical teams that need to justify AI-assisted decisions to reviewers, auditors, or future selves — with traces that aren't just chat scrollback.
• Tech leads and architects who care that the assistant stays consistent across days, weeks, and people working on the same project.

Three pillars

Trust

Every response is structurally validated before it reaches you. When the model proposes a real architectural choice, it surfaces it as an interactive Decision Gate — a card with concrete options, their trade-offs and risk profile, where you click your pick (or propose your own alternative), so the call is made by you, not assumed by the model. When the agent edits code, the extension type-checks (and lints) the touched files and feeds errors back so it self-corrects before the cycle ends — and newly-written code is grounded against a real language grammar to catch hallucinated imports before they land.

Memory

Your project's accumulated context — decisions taken, learnings captured, contradictions detected — travels with every cycle. The longer you work in a project, the more relevant the assistance gets, because it's grounded in your prior work and not a fresh chat each time. That memory isn't limited to what's recent, either: once history rolls into the project's long-term archive, asking about a decision from weeks ago retrieves the real record instead of losing it to scrollback.

Control

Bring your own API key. Pick from multiple providers, switching whenever you want. Your code goes directly to the LLM provider you selected — no proxy, no middleman. Project memory stays in your repo, in your control.

Multi-provider, your choice

All requests route directly from your machine to the provider you chose. Pricing varies by model — see each provider's official pricing page for current rates.

How a typical cycle looks

You describe what you want. The assistant reviews your project's context, your recent decisions, and your prompt. From there, one of three things happens:

1. A focused clarification when intent is ambiguous.
2. An interactive Decision Gate when there's a real architectural choice to make — you click an option (or propose your own), the agent continues in the same cycle.
3. A structured response — validated before you see it. If tools are involved, you watch each step execute, the agent type-checks its own edits and self-corrects, and you can interrupt at any time.

Every cycle is recorded in the Audit tab, so you can come back later and see what changed, what was decided, why, and what the alternatives were.

Three modes

• Architect Mode — Analysis only. Read-only by design — it only gets file-reading tools, so it physically cannot write even if the model tries. Useful for planning, code review, exploring trade-offs.
• Plan Mode — Produces a structured plan document for your review (Goal, Scope, Files to modify, Steps, Risks, Rollback, Open questions) using read-only tools only. Click "Execute Plan" in chat to run it — if the workspace is a git repo, execution runs on an auto-created isolation branch so you review the diff before merging.
• SYNAPTIC Mode — Full protocol with tool execution, interactive Decision Gates, and in-loop verification. Use this when you're ready to build.

You switch modes per cycle. Same conversation, different capability.

Project Rules — your conventions, auto-applied

Most AI tools forget your project preferences between conversations. SYNAPTIC lets you write them down once in a file the agent will read on every cycle.

A rule is plain Markdown with a short YAML frontmatter at the top:

---
name: typescript-strict
description: TS conventions for src/
whenFilesMatch: ["src/**/*.ts", "src/**/*.tsx"]
whenMode: ["synaptic", "plan"]
priority: 60
---

Use `unknown` over `any` in catch blocks.
Prefer composition over inheritance for services.
Avoid default exports — always named.

Drop the file at .synaptic/rules/<name>/RULE.md in your workspace, save, and SYNAPTIC will auto-inject the body into the system prompt for every cycle whose context matches the conditions. Omit whenFilesMatch or whenMode to match anything. Higher priority rules are injected first when the budget runs out.

Discoverability without ceremony:

• Above the prompt input, a subtle indicator shows N rules active for the most recent cycle. Click to see which rules fired + a popover with each rule's details.
• The sidebar Quick Actions has a Rules button that opens a modal listing EVERY authored rule (matching or not), with filter tabs (All / Matching / Workspace / Legacy), click-to-open for source files, and one-click + New Rule to scaffold a fresh one.
• The command palette has SYNAPTIC: New Rule / Open Rule / Reload Rules for keyboard users.

Workspace rules live in your repo and travel with the project — commit them to share with the team, or .gitignore them for personal use. The folder ships with no built-in rules; the maintainers will only add ship-time defaults if marketplace users report concrete demand. See the changelog for the field-monitoring policy.

If you used the slash-skill catalog of 0.10.x (/audit-strict, /decision-gate, etc.) — those are gone in 0.11.0 (the model didn't see real adoption). Any .synaptic/skills/<name>/SKILL.md files you authored keep working through 0.11.x as legacy rules; migrate them to .synaptic/rules/<name>/RULE.md before 0.12.0.

Meet your project Companion

Beyond the main protocol, SYNAPTIC ships with a Companion — a named, opinionated assistant that lives alongside your workspace.

Each session you get one of five personalities (Nyx, Pip, Mux, Zig, or Syn) with their own expressions and tone. The Companion isn't there to write your code. It reads your project's context — the decisions you've made, the path you're on, the questions you've asked — and offers grounded perspective when you ask for it. It has a personality. It can disagree with you. It remembers what you told it across the conversation.

Some users treat it as a rubber duck that talks back. Others use it to second-guess a Decision Gate before committing. It's playful, but it isn't a toy — it carries the same project memory the main agent does, which means its opinions are anchored in your actual work, not generic advice.

The Companion uses your main provider and does not consume cycles.

Plans

A cycle is one complete prompt → response interaction. Every plan ships with the same features — only the monthly volume differs. Quota resets on the first of each calendar month.

What's new in 0.15

0.15.1 — Maps panel crash fix for initiatives with a non-standard shape

If an initiative got created with a field missing or shaped differently than expected (for example, no dependsOn list at all), opening the Initiatives tab could blank the entire Maps panel with no error message — not just fail to show that one initiative. Both Maps views (the dependency graph and the per-initiative lifecycle history) now tolerate missing or unexpected fields instead of crashing, and the agent's own instructions for creating a new initiative now include the exact field shape to write, reducing how often this can happen in the first place. If you hit a blank Maps panel on 0.15.0, this release fixes it — no data was lost, and nothing needs to be redone.

0.15.0 — Roadmap as a graph of initiatives, plus smarter output-token budgeting

Your roadmap is now a graph, not a list. Previous versions tracked project roadmap as one linear file — fine for a small project, dishonest once real work has several initiatives running at once: a migration in progress, a feature that depends on it, a redesign that replaces an older one. Each initiative now lives in its own record with a real lifecycle (proposed, accepted, in progress, blocked, implemented, archived, superseded, deprecated — ten states, in the spirit of Architecture Decision Records: nothing is silently edited away, a change of direction is a new state with a reason, not a rewritten history) and two kinds of relationship to other initiatives: what it depends on, and what it replaces.

• Two new views in the Maps panel's Initiatives tab: a dependency graph (what's blocking what, what replaced what) and, one click into any initiative, its full lifecycle history — every state change, when, and how it happened.
• Traceability that reaches into your project's archive. Click a point in an initiative's history and the question opens in Architect Mode, grounded in your real project record — including history old enough to have rolled into long-term archive. Validated against a real 341-cycle project: asked about cycle 1 from a project currently 340 cycles past it, retrieved the exact original prompt and cross-referenced the actual document it had reviewed that day — not a guess at what probably happened.
• The assistant won't quietly duplicate an initiative. Before proposing a new one, it reads what already exists; if something similar is already tracked, you get a real Decision Gate — create it anyway, fold the request into the existing initiative, or skip it — instead of two initiatives silently drifting apart. A second, code-level check blocks an exact or near-exact duplicate from being written even if that step is somehow bypassed.
• Hardened against several edge cases surfaced by real use before this release shipped: data the model wrote in a slightly wrong shape, a status value outside the fixed vocabulary, a relationship that needed to point at more than one other initiative at once — all now handled defensively (shown clearly, never a crash) rather than assumed away.

Output token budgeting, the other half of context engineering. Most of the current conversation about context engineering is about what goes into a model's context window. This release addresses what comes back out. The output ceiling per response is now raised across every API provider (matching the level already proven safe for Google Gemini, where the same class of issue was found and fixed earlier), user-configurable via synaptic.maxOutputTokens for anyone running larger tool-heavy cycles, and monitored proactively — if a response uses most of its budget without actually being cut off, you get a quiet heads-up before it becomes a real truncation. Also fixed: a cycle that completed real file changes but ran out of budget writing its own closing summary used to read as a silent failure ("the model may have failed silently, try again") — it now tells you plainly that the work was applied and offers to continue for the summary.

0.14.1 — Decision history now actually tracks what you decided

Every Decision Gate you resolve by clicking an option — the normal way most people use them — now gets properly recorded in your project's decision history and becomes searchable through long-term project memory. This was silently broken before: the gate worked, your choice took effect, but the record of what was decided never made it into history. Also fixed: a rare case where a Decision Gate could be followed by a completely empty, silent response if the model's next turn hit its own output limit — you'll now get a clear message telling you to ask it to continue instead of wondering if anything happened.

0.14.0 — Long-term project memory search

Project history now reaches further back than the current session. Once a chunk of history rolls into the project's long-term archive (roughly every 50 cycles), asking about it — "why did we choose Redis for sessions?", "what happened in cycle 33?" — retrieves the actual decision and outcome instead of forcing a manual search through old files. Works in SYNAPTIC, Architect, and Plan modes. Validated end-to-end against a seeded project history with a real model: correctly retrieved a multi-cycle-old architectural decision by topic and a past failure by cycle number, and correctly stayed silent on unrelated questions. Not available with local CLI providers (Claude Code CLI, Codex CLI, Gemini CLI) or in the Companion Assistant, for the same reasons other agentic tools already aren't. No embeddings or external search index involved — retrieval runs entirely on your local project files, consistent with SYNAPTIC's no-proxy design.

What's new in 0.13

0.13.2 — Privilege-operation classifier no longer blocks pasted output

Pasting terminal output that mentioned "sudo" (an install log, an error you were asking about) used to be treated the same as an instruction to run a privileged command, blocking the cycle outright. Real privileged execution is independently blocked at the tool layer regardless of chat text, so this specific detection no longer hard-blocks — it now shows a short non-blocking notice instead, and every other protocol check (forced push, forced install, dynamic code execution) still blocks exactly as before.

0.13.1 — Architect and Plan Mode conversation continuity

Architect Mode and Plan Mode now keep their own short conversation buffer, separate from SYNAPTIC mode's. Previously, asking either mode to "continue with what you proposed" left the model with no memory of its own prior turn in the conversation — it either searched back through the project log to reconstruct context, or answered without it. Validated via real dogfooding on a live project: a follow-up Architect turn that previously required extensive file search to recall its own proposal now resolves immediately, because the context is already there. No change to SYNAPTIC mode's existing behavior.

0.13.0 — Audit Report Export

A new Export button in the Audit tab produces a navigable Markdown report from your project's provenance log, at three depth levels:

• Executive Snapshot — 1-page plain-text summary, no LLM, instant.
• Auditor Report — multi-section narrative across selectable lenses (Forensic, AI Governance, Quality Control, Productivity Metrics, Cost & Model Optimization, Supply Chain), plus a Recommendations section.
• Forensic Dump — raw records with a minimal header, no narrative.

All numeric metrics, percentages, and rankings in the report are computed deterministically in code — the LLM only narrates, it never fabricates figures, and every narrated section ends with a disclaimer citing the model used. The report also distinguishes "apparent quality" (raw success rate) from "effective quality" (excluding SYNAPTIC's own protective rejections, like blocking a test-fabrication attempt), so a rejection SYNAPTIC caught on your behalf doesn't read as the system failing.

This release also fixed Decision Gate linkage in the provenance audit trail: edits that implement a decision you made at a Decision Gate are now correctly attributed to that gate, so the Audit Report's "Decision Gates linked to file edits" metric reflects reality going forward. Records logged before this fix are not backfilled.

What's new in 0.12

0.12.0 — Three new providers (Qwen, DeepSeek, Kimi)

0.12.0 ships three new API providers for users who want broader model choice — bringing the total to eight API providers plus three local CLIs. All three are OpenAI-compatible drop-ins (you paste your API key, pick a model, prompt as usual), and all three were validated against SYNAPTIC's protocol with empirical smoke testing before this release.

• Qwen (Alibaba) — Qwen3-coder-next family via DashScope International. Default model qwen3-coder-next (262K context window, function calling). Get your API key at modelstudio.console.alibabacloud.com.
• DeepSeek — V4 Pro (capability) and V4 Flash (cheap). Default model deepseek-v4-pro. Get your API key at platform.deepseek.com.
• Kimi (Moonshot) — K2.7-code family. Default model kimi-k2.7-code ("Kimi's strongest Coding model"). K2.7-code-highspeed available as a speed-optimized variant. Get your API key at platform.kimi.ai.

Transparency note on Qwen tool-use

To get the most consistent SYNAPTIC protocol engagement with Qwen — Decision Gates rendered as interactive UI cards rather than markdown text — the extension automatically appends a short tool-use instruction to your prompt when Qwen + SYNAPTIC mode + tool migration are all active. Empirical smoke testing showed Qwen needed this nudge to invoke protocol tools natively; DeepSeek and Kimi did not. The injection is logged to console ([DG-265] Qwen tool-use augmentation injected ...) and can be disabled via the setting synaptic.qwen.toolUseAugmentation.enabled if you prefer manual prompt control.

The equivalent settings for DeepSeek and Kimi (synaptic.deepseek.toolUseAugmentation.enabled / synaptic.kimi.toolUseAugmentation.enabled) ship disabled because those providers engage with SYNAPTIC tools natively without it. They exist as opt-in for advanced users who want extra reinforcement.

What's new in 0.11

0.11.0 — Project Rules (replaces Skills v2)

0.11.0 replants the slash-skills feature of 0.10.x into a Cursor Rules-style auto-injection model. The headline change: stop asking users to remember /audit-strict and start letting them write their project conventions once and have the agent follow them automatically.

• Project Rules — drop a Markdown file at .synaptic/rules/<name>/RULE.md with a short YAML frontmatter (which files / modes it applies to + a priority) and a body in plain prose. The agent auto-injects matching rules into the system prompt for every cycle whose context matches the rule's conditions.
• Active rules indicator — a subtle badge above the prompt input shows N rules active for the most recent cycle. Click to see each rule's name, tier, priority, and description. Renders nothing when zero rules match (zero footprint UX).
• Rules browse modal — a Rules button in the sidebar Quick Actions opens a modal that lists EVERY authored rule, not just the matching ones. Filter tabs cover All / Matching / Workspace / Legacy; click any card to open its source file. Footer buttons trigger + New Rule and Reload.
• Three palette commands: SYNAPTIC: New Rule (scaffold), SYNAPTIC: Open Rule (quick-pick), SYNAPTIC: Reload Rules (manual reload — the file watcher also picks up changes with 300 ms debounce).
• Migration note for 0.10.x users: the slash commands (/audit-strict, /decision-gate, /explain-bitacora, /sync-intelligence, /skills, /reload-skills) are gone — the prompt forwards verbatim now. Existing .synaptic/skills/<name>/SKILL.md files keep working through 0.11.x under a compat layer (loaded as legacy rules, always-on, priority 30, console warning on load). Migrate them to .synaptic/rules/<name>/RULE.md before 0.12.0.

See the dedicated Project Rules section above for a worked example.

Previously

0.10 highlights — Init Gate (opt-in workspace model so SYNAPTIC doesn't stain unrelated projects), monthly quota with subscription tiers, eight providers at the time (Codex CLI and Gemini CLI added — Qwen, DeepSeek, Kimi arrived in 0.12.0), Save Progress (commit + optional push without consuming a cycle).

0.9 highlights — Interactive Decision Gates, Plan Mode, in-loop verification (tsc + ESLint with self-correction), anti-hallucination grounding (newly-written code parsed against a real grammar), Audit tab, prompt caching, security & hygiene scan.

Known issues: a few cosmetic UI rough edges in the chat panel and Audit tab are still being polished — functionality is unaffected. The function-calling migration runs in dual-write mode (legacy text path still authoritative for protocol signals).

Getting Started

1. Install the extension from the VS Code Marketplace
2. Sign in with Google or GitHub (OAuth PKCE)
3. Add an API key for your preferred provider (Ctrl+Shift+P → "SYNAPTIC: Manage API Keys")
4. Open the Chat Panel with Ctrl+Shift+Y (or Cmd+Shift+Y on Mac)
5. Send your first prompt and start a cycle

Keyboard Shortcuts

Extension Settings

Provider notes

These notes are important if you plan to use a local CLI integration.

Claude Code (CLI)

SYNAPTIC spawns the claude binary as a subprocess and never handles Anthropic credentials directly. Per Anthropic's third-party integration policy, authenticate Claude Code with an Anthropic API key via claude login. Subscription OAuth tokens (Claude Pro, Max, Team, Enterprise) are not permitted for third-party integrations, even indirectly via subprocess.

Codex CLI

Codex CLI's default approval/sandbox behavior cancels MCP tool calls mid-execution. To make SYNAPTIC's tool calls work with Codex, the extension spawns Codex with the --dangerously-bypass-approvals-and-sandbox flag. The first time you submit a SYNAPTIC-mode prompt with Codex selected, the extension shows a consent modal explaining what the flag does and why it's needed. Consent is stored per-workspace and can be revoked any time from the chat header.

Auxiliary features (Companion chat, Tech Stack Analyzer, UI Map Analyzer) never use this flag.

Gemini CLI

SYNAPTIC spawns the gemini binary as a subprocess. Authenticate with an API key (GEMINI_API_KEY or GOOGLE_API_KEY env var, set before launching VS Code).

Folder trust: Gemini CLI uses a workspace "folder trust" model for tool access. If tool calls don't work, run gemini interactively once in the workspace and confirm the trust prompt.

Image attachments with local CLIs

When you attach an image and the active provider is a local CLI (Claude Code / Codex / Gemini), SYNAPTIC writes the image to <workspace>/.synaptic-attachments/ so the CLI's internal Read tool can load it. The directory will appear in git status. SYNAPTIC deliberately does NOT auto-add it to .gitignore — Gemini CLI's Read tool refuses to load files matched by any standard git-ignore mechanism. Files older than 24 hours are cleaned up automatically.

If you don't use Gemini CLI and prefer a clean git status, you can safely add .synaptic-attachments/ to your project's .gitignore manually.

Privacy

• API keys are stored in VS Code's encrypted secret storage. Never transmitted by the extension itself.
• LLM calls go directly from your machine to the provider you selected. No request passes through a SYNAPTIC server.
• Project memory lives inside your workspace, in .synaptic/. You decide whether to commit it or gitignore it.
• Sign-in via Google or GitHub OAuth (PKCE flow).
• The extension records cycle metadata (model used, duration, score) to enforce monthly quota. It does not transmit your prompt content or the model's response.

Requirements

• Visual Studio Code 1.85.0 or later
• A Google or GitHub account (for sign-in)
• An API key from one supported provider, or one of the supported CLIs installed (claude, codex, gemini)

License

MIT — the full source is on GitHub.

Publisher

Built by GoLab — Conexiones Sorprendentes.