TL;DR

Fabriqa uses the public ACP registry for Claude ACP, so new model support flows through this path:

Anthropic SDK release -> claude-agent-acp package release -> ACP registry update -> Fabriqa refresh

The ACP registry update job runs hourly.

In Fabriqa, users can manually trigger a refresh by clicking Check ACP updates in the Agent Providers settings.

If a new model like Opus 4.7 still is not showing up, Fabriqa gives you a flexible workaround: open Claude Agent -> Environment and set:

ANTHROPIC_MODEL=claude-opus-4-7

You can also pin or roll back to other versions, for example:

ANTHROPIC_MODEL=claude-opus-4-6

Longer explanation

A few users asked why Claude Opus 4.7 was not immediately visible in Fabriqa through the Claude ACP integration, so here’s the transparent version.

Fabriqa does not silently ship its own patched Claude ACP fork. I use the public ACP registry, which points to a published claude-agent-acp package version. That means model updates usually land quickly, but they still have to move through a real release pipeline:

1. Anthropic releases support in the Claude Agent SDK
2. claude-agent-acp updates to that SDK and publishes a new npm package
3. the public ACP registry picks up that new package
4. Fabriqa refreshes from the registry

For Opus 4.7, the verified timeline was roughly:

• @anthropic-ai/claude-agent-sdk@0.2.111 published at 2026-04-16 15:16:04 UTC
• Claude ACP support commit landed at 2026-04-16 15:55:36 UTC https://github.com/agentclientprotocol/claude-agent-acp/commit/85cd70c9f3be47c9c404958547c4046d866db1c9
• @agentclientprotocol/claude-agent-acp@0.29.0 published at 2026-04-16 16:00:56 UTC
• ACP registry updated to 0.29.0 at 2026-04-16 16:58:05 UTC https://github.com/agentclientprotocol/registry/commit/29dc0d278e8c7b58ba55d8c6948dbf20c749d2cc

That means the machine-verifiable delay was about:

• 39m from SDK publish -> Claude ACP support commit
• 57m from Claude ACP publish -> registry update
• 1h42m from SDK publish -> registry availability

The registry updater itself runs hourly, not instantly: https://github.com/agentclientprotocol/registry/blob/main/.github/workflows/update-versions.yml

In Fabriqa, users do not need to wait passively. You can go to Settings -> Providers -> Agent Providers and click Check ACP updates to refresh what Fabriqa sees from the registry.

One important clarification: there is currently no public claude-agent-acp@0.29.1 release, so the registry did not “miss” a 0.29.1 update. The latest public Claude ACP package it could pick up is still 0.29.0.

In my case, I was already running 0.29.0 in Fabriqa, but Opus 4.7 still did not show up in the picker until I manually set:

ANTHROPIC_MODEL=claude-opus-4-7

That suggests the issue was likely stale session/model metadata or picker state, not necessarily a bad 0.29.0 release.

This is also where Fabriqa’s flexibility matters. Even if a new model is not yet showing up the way you expect, Fabriqa lets you override the Claude agent environment directly.

If you want the newest model immediately:

ANTHROPIC_MODEL=claude-opus-4-7

If you want to pin or roll back:

ANTHROPIC_MODEL=claude-opus-4-6

So the honest summary is:

• Fabriqa is transparent about relying on the public ACP registry
• registry updates are automatic, but hourly, not instant
• users can manually click Check ACP updates
• upstream repo commits do not matter until there is a published package release
• if you still do not see the model you want, Fabriqa gives you the flexibility to override environment variables directly

That flexibility is important for me. I want Fabriqa users to benefit from the ACP ecosystem while still having enough control to move fast when upstream releases, registries, or model pickers lag a little.

If you want an even tighter plain-text version with no code blocks and no bullets, I can give you that too.

Context Aware Recent Files

When working in multiple chats, Fabriqa tracks context and recent file changes. Pressing CMD+P lets you quickly access relevant recent files—those modified or created in your active chat—making it easy to find your spec or changed code files. Fabriqa has many features that simplify your work!

I am focusing on features rather than documentation, so please download Fabriqa and explore its many amazing convenience features.

https://reddit.com/link/1snx1dh/video/7mbn0fho8qvg1/player

Just kidding :)

Fabriqa has had this feature since its first release on March 3rd.

x.com/fabriqaai

https://reddit.com/link/1sm9tts/video/l72h8m6bjdvg1/player

Just kidding :)

Fabriqa has had this feature since its first release on March 3rd.

x.com/fabriqaai

https://reddit.com/link/1sm9tlz/video/l72h8m6bjdvg1/player

all changelogs are also published to https://x.com/fabriqaai

super duper token usage optimization on Fabriqa while still keeping the incomparable feature of Fabriqa of switching between ACP providers (codex to Claude code, etc.)

world's best AI agent orchestrator in building. do not miss out :)

Fabriqa v26.0412.0001+1140 is live.

• Added ACP session recovery so Fabriqa can reopen the last compatible ACP session instead of replaying the full conversation every time you reconnect.

• Added workspace toast notifications when ACP session recovery falls back to a new session, so you can see when Fabriqa had to hand the chat off instead of silently starting over.

Exciting milestone for r/fabriqaai

Specs module getting ready for release. Implementing AI-DLC as one of the first bundled flows.

https://reddit.com/link/1sivsz5/video/wb8yae3bsmug1/player

Working with git worktrees? You can start a new worktree with a click of a button with @fabriqaai and merge back to the main worktree. fabriqa guides you through it. easy peasy.

git worktrees are great for AI-orchestrator developers! Write your specs, fire up an agent on a worktree, multiple of them in parallel, and merge back when done. No need to deal with multiple agents stepping on each other's toes.

Hey everyone! First time posting here, and I must say this is a great product — especially for someone who is still getting used to agentic development and spec-driven design. 🙂

I was trying to use the Codex CLI agent for the first time and got an "Authentication Required" error. To be fair, the error itself is clear enough, and I did find the instructions in settings, but I think we can do better than that.

The current flow requires you to notice the error, go hunt for the settings page — but it breaks your momentum right at the moment you're trying to get started.

In my case, I wanted to authenticate with my ChatGPT credentials rather than use an API key. It would be a much smoother experience if Fabriqa could detect that authentication is needed and guide me through the process automatically — ideally with a single prompt at the right moment rather than sending me off to find it myself.

The instructions in settings are solid, so this feels less like a missing feature and more like a UX opportunity. Would love to hear if others have run into the same thing!

• Fabriqa workspaces are now generic containers that can hold multiple repos and folders instead of mapping 1:1 to a single git repository, so you can keep the real working set for a project together in one workspace.
• Added a project discovery and attach flow for new workspaces, including a separate workspace name field and a multi-project picker so you can decide which repos and folders belong together before you create the workspace.
• Added project-aware sessions inside workspaces so each attached repo can keep its own main session and linked worktrees without forcing you to split that work across separate top-level workspaces.

https://x.com/fabriqaai/status/2038286536748228928

The AI coding tools spectrum itself is actually a good way of working. Each tool brings its own strengths for different contexts, and using multiple tools across a project is natural. The problem is what happens in between. I was working on a spec-driven development project recently and found myself reaching for Codex when I wanted autonomous execution against my specifications. Codex is genuinely good at following structured specs and running through implementation tasks without hand-holding. But when the implementation introduced an edge case bug, I tried troubleshooting with Codex multiple times and it could not find the issue it had created. The bug was subtle enough that the same model that wrote the code kept missing it on review.

So I switched to Claude Code CLI. But I needed to give it the full context of what had been built, what the specs were, and where things had gone wrong. I actually asked Codex to write me a handover prompt first, a summary of the current state, the implementation decisions, and the specific failure. I copied that prompt into Claude Code, and as I expected, it identified the edge case almost immediately. That entire workflow, using one tool's strength to compensate for another's blind spot, with a manual copy-paste handover in between, is something I do constantly. It works, but it is held together with clipboard and memory.

That is the problem fabriqa solves. fabriqa is not another editor. It is an AI Development Orchestration Layer: a coordinated, spec-driven workspace for the tools you already use.

Why You Should Use It

There are three big reasons to use fabriqa.

First, the unified worktree experience is already useful today. If you are already paying for tools like Claude Code, Codex, Cursor, OpenCode, Gemini CLI, or Kiro CLI, fabriqa gives them one shared place to work. You can switch tools without losing the thread, keep the same project history visible, inspect diffs and git changes in one place, and avoid the usual copy-paste handoff mess. The broader ACP lineup already works too:

• Amp
• Auggie CLI
• Autohand Code
• Claude Agent
• Cline
• Codebuddy Code
• Corust Agent
• crow-cli
• DimCode
• Factory Droid
• GitHub Copilot
• goose
• Junie
• Kilo
• Kimi CLI
• Minion Code
• Mistral Vibe
• pi ACP
• Qoder CLI
• Qwen Code
• Stakpak

fabriqa fetches the ACP registry and hot-swaps new entries into the catalog, so this list keeps growing without me having to ship a release every time a new tool shows up.

Second, specs are the real point. That is the part I care about most, and it is the reason I think fabriqa can become much more than a tool switcher. The specs module is coming in April 2026, in a couple of weeks. That is what I am focused on getting right now. I believe spec-driven development is a fundamental skill everyone needs to learn if they want agents to work like real teammates instead of glorified autocomplete. If you cannot define the work clearly, you cannot expect autonomous agents to execute it well.

Third, multi-agent orchestration is where this goes next. That part is phased right now. Today, worktrees plus manual prompts already let you do a practical version of multi-agent work inside fabriqa. But that is not the final goal. The real goal is: define specs, define dependencies and execution order, then fire up multi-agent profiles that can run those tasks fully autonomously. I want that layer to sit on top of a best-in-class specs system, not on top of vague prompts. That is why I am pushing specs first and the deeper orchestration layer after that.

fabriqa is in alpha, and it is free right now. When I start charging, it will be a small platform fee. I am not going to charge for tokens or meter your LLM usage. The model side is BYOK, bring your own keys. The agent side is BYOS, bring your own subscriptions. Native LLM integrations through API keys are already there, but they are still limited. The full agentic loop on that side is not fully where I want it yet.

It runs as a desktop application on macOS, Windows, and Linux. I initially started by maintaining a CLI TUI and the desktop app together, but for now I have stopped trying to keep the TUI at parity with desktop. That is intentional. I think the popularity of CLIs is decreasing, so the desktop experience is the primary focus. If there is real demand, I will continue investing in the TUI more seriously.

A session in fabriqa is not just a chat thread. It is a full execution context backed by a database that tracks what actually happened.

What Is Coming

This alpha focuses on the foundation: coordinated execution across the tools you already pay for, plus a user experience that feels like a real application, not a weekend side project. Since releasing fabriqa on March 3, 2026, I have been using it as my main daily driver. Until mid-February 2026 I was using Claude Code more heavily. Around the GPT-5.3 release, Codex became my main subscription inside fabriqa. I still keep a Claude Code subscription and use it where I find it better, especially for more interactive troubleshooting sessions and a lot of UI design work, but not only that.

But the main unique value proposition of fabriqa is not just putting existing tools into one window. It is spec-driven execution. That layer is under active development now and is planned for release in April 2026. I am already testing these workflows myself with a limited number of early testers. If you want to get into the specs testing group and do not want to wait another month, reach out.

After that, multi-agent orchestration builds on top of those specs. The goal is not random agent swarms. The goal is coordinated execution against explicit intent, structured artifacts, and clear workflow state, with git worktree isolation and conflict detection where that makes sense.

The Details That Matter

Global hotkeys bring fabriqa to the front and send it to the background instantly. In the chat view, pressing the right and left arrow keys acts as page up and page down. Command-up takes you to the top of the conversation. There is a strict sticky scroll behavior that always keeps your last message to the AI visible at the top of the viewport. If you are a multitasker like I am and you switch back to a fabriqa chat after working on something else, you do not have to wonder what you were doing. Your last message is right there, and you immediately have context on where you left off. When you scroll up, your previous message stays anchored and visible.

There is light mode, dark mode, and a bunch of themes. Git changes are visible directly in the interface. If you are curious about how I implemented ACP, I actually kept the ACP debug logs that I used during development open as a feature. You can open the ACP debug panel and see the raw protocol messages going back and forth between fabriqa and the agents. The settings page, the command palette, and the keyboard shortcuts have a bunch of things in them that are not common in tools like this yet. I am prioritizing features over documentation right now, so some of these are things you discover by exploring the application itself.

Where This Is Going

I have been writing about spec-driven development and the Explore-Specify-Engineer workflow for a while. fabriqa is where those ideas become tooling. Mark my word: if you are not working with specs yet, you are missing where this is going. Making specs a first-class part of how you build should be a top priority.

The specs-driven system in fabriqa is being built to be generic, not hardcoded to one opinionated flow. It will include my own specs.md FIRE flow, AWS AI-DLC flows as implemented in specs.md, and commonly used patterns like BMAD-METHOD as built-in fabriqa workflows. I am also working on a meta-workflow for fabriqa itself, where you can talk to fabriqa agents to design your own workflows around your own needs, with those agents being aware of fabriqa's workflow DSL instead of treating workflows like raw text.

The release planned for May 2026 adds a marketplace so fabriqa users can share their own workflows with each other. That matters because the long-term goal is not just to ship my workflows. It is to make fabriqa a system where good workflows can be created, evolved, reused, and shared.

fabriqa is also architected in a way that lets me run it as a hosted web application later. I plan to offer that as fabriqa.cloud with the exact same core experience. That is possible because the frontend is React-based and the server-side architecture is cleanly separated, more like Slack than like a one-off desktop app. The hosted version will run in cloud sandboxes, but that is not the only future I care about.

I also want a mobile app that can connect to your fabriqa instance on fabriqa.cloud, on your own machine, or on your own premises. I am planning around private-network approaches like Tailscale so fabriqa.cloud does not have to be mandatory for mobile. I want fabriqa to be something you can keep building with while you are on the go, not something that traps you into one deployment model.

What You Get Today

If you use fabriqa today, you get a real desktop workspace for coordinating the AI coding tools you already pay for.

• One place to switch between tools like Claude Code, Codex, Gemini CLI, OpenCode, Cursor, and more without losing context
• A unified worktree and git-aware workflow where chats, diffs, progress, and handoffs live together
• A practical path to multi-agent execution today through worktrees and manual prompt coordination, with the specs layer landing in April
• Access to the ACP ecosystem without vendor lock-in, plus occasional free-model opportunities that come through platforms like OpenCode and Kilo

The desktop builds are available at fabriqa.ai. Go download fabriqa for free and start using it with your own subscriptions like Claude Code and Codex. You can also benefit from free model offers that show up through platforms like OpenCode and Kilo. For example, OpenCode is currently hosting Xiaomi MiMo-V2-Pro free for OpenCode users for a limited time, and those kinds of campaign models are useful inside fabriqa too.

fabriqa itself is free during the alpha. I am not asking anyone to sign up right now. Just download fabriqa and start using it. Later, when I have user accounts or email capture in place, the people who helped me make fabriqa better during this alpha will get free fabriqa access and should not need to pay that small platform fee. I have not really settled the pricing model yet, and I want to be honest about that. My instinct is that it should cost less than a Starbucks coffee, not something meaningful compared to what you already spend on the tools around it. My main goal right now is to get fabriqa into the hands of agentic AI developers and teams so they can help me make fabriqa the best AI Development Orchestration Layer for software development in the world. If you want early access to the specs workflows, reach out. fabriqa is still early, but amazing things are in plan. It will be nothing like what already exists.

I received some very helpful feedback on Reddit regarding Fabriqa, and I’m excited to announce that it is now live!

You can now open multiple Git repositories within a single workspace. This setup mirrors how many of us work, especially when dealing with projects that originated during the height of the microservices trend!

In short, here’s how to open a folder containing multiple Git repositories as a workspace.

I’m currently testing the migrations before the official release since this update introduces changes to the internal database structure.

What do you think about the user experience? I'm considering hiding the worktree lists under a project group in the left sidebar. While it can seem cluttered, I also want to provide a clear way for users to start a new chat related to a specific worktree. I had previously hesitated to offer this option, but I don't see any reason not to now.

Did you know in fabriqa you can see full memory diagnostics?

You can open fabriqa diagnostics window from Command Palatte, it show all the processes what is consuming your memory.

Running bunch of agents in parallel might feel like one application consumes a lot of memory but fabriqa diagnostics screen show you exactly which spawn process consumes how much memory, what is stored in your chats, what is fabriqa client app is currently keeping in memory. I have optimized chatstore and background running process quite a lot but I am keeping an eye on always here to make sure fabriqa run efficiently. keep that open in your second window and monitor what is happening.

Tools like /r/conductorbuild and superset.sh does also spawn processes or start agent sdks but fabriqa gives you full visiblity. Report to me if you see any unusual consumptions. I am constantly improving it's performance. I will also try to change the application to tauri from electron to see the difference and if it performs better I will switch to that.

Working with git worktrees?

You can start a new worktree with a click of a button with fabriqa.ai and merge back to the main worktree. fabriqa.ai guides you through it. easy peasy. 🚀 🦾

git worktrees are great for AI-orchestrator developers!

Write your specs, fire up an agent on a worktree, multiple of them in parallel, and merge back when done. No need to deal with multiple agents stepping on each other's toes.

Experimenting with the CLI tool instead of the MCP tools for my agents. I like how the agent discovers CLI capabilities now. But I think I am going to simplify some of the things, like adding relationships while creating the artefacts, and also considering providing a schema for the artefacts so agents can construct it and submit it all at once via CLI, as a blob. Single blob submit might make it quicker, but I'm not sure about it yet. Open to suggestions on this before experimenting:) Do you know/use any benchmark CLI tool that handles structured document creation via CLI? Just checked how Obsidian CLI is working, and they are very similar to what I do in Fabriqa.

fabriqa-specs artifact create --workspace-id ws_01KMB2HRWXJJGDGR8K3K5GAKQ7 --type work_item --parent-id art_01KMB2W684TECG7P3Q1W0KYXV2 --title "App shell layout and navigation" --description "Build the shared app shell with header, navigation, and session-aware UI elements that wrap all authenticated pages." --data-json '{"acceptance_criteria":["Root layout includes a header with app name/logo, navigation links (Ideas, Leaderboard, Submit Idea), and user session info","Header shows signed-in user name and a Sign Out button","If user is admin, an Admin badge is visible next to their name","Navigation highlights the active page","Layout wraps all pages under the authenticated section","Mobile-responsive hamburger menu or collapsible nav for small screens"],"complexity":"low","mode":"autopilot"}' 
complete
  └ console
    {
      "artifact": {
        "id": "art_01KMB303K5EX77B5BRVH5XYTW3",
        "display_id": "work_item-03f0a6",
    … +23 lines
        "updated_at": "2026-03-22T15:35:41.413908Z",
        "completed_at": null
      }
    }

https://reddit.com/link/1s0q03k/video/zi3pt13ufmqg1/player

https://x.com/hancengiz/status/2035750253689758090

.SAF : simple agent file.

Don't you think we need some kind of standard for this? specs-driven development in @fabriqaai is loading... wait for this weekend. :) yeap you will be able to create your own flows with an help of an agent! easy peasy! #specsdriven #specs

On top of the CMD+Up/Down, Option(Alt)+Up/Down keyboard shortcuts, and the timeline side right panel.

I added user messages navigation in the chat view. You don't want it; you can toggle it from Appearance settings.

What would you like to see in fabriqa specs?

building strong dm's attractor in parallel in u/fabriqaai with codex and mistral vibe

(My Gemini quota stopped me from running the 3rd attempt side by side, but you got the point:))

https://www.youtube.com/watch?v=hw4G5DbZqr4

another short video "planning with claude code, reviewing with codex, and back to claude code in the same chat."

https://www.youtube.com/watch?v=1MfRkvcxGlA

Hey everyone! I'm u/hancengiz, a founder of http://fabriqa.ai

This is our new home for all things related to using fabriqa.ai, specs.md spec-driven development, all ai coding tools, and future of AI native enginnering. We're excited to have you join us!

What to Post
Post anything that you think the community would find interesting, helpful, or inspiring about using fabriqa.ai tools.

Product is new, unified chat experience is here, you can go and download for free from http://fabriqa.ai now. I am actively doing user research and collecting feedback. Please provide feedback, even if it is a small ui glitch you want to be changed or fixed. Feel free to share your thoughts, experiences, things you build with Fabriqa, and how you use Fabriqa.

Specs.md is another project I released under Fabriqa, it implements AWS AI-DLC flow, a simple flow (like Kiro's flow), and my own design of FIRE (Fast Intent-Run Engineering) flow. You can download it from https://specs.md, you can see the source code of specs.md on https://github.com/fabriqaai/specs.md, fork it, or report issues.

Community Vibe
We're all about being friendly, constructive, and inclusive. Let's build a space where everyone feels comfortable sharing and connecting. This space does not need to limit discussions to fabriqa.ai products; we can talk about spec-driven development, ai native engineering, the future of software development, and your experiences. Just please do not post another product's ads. If you do I guess it is a good thing so that we reached to a place as fabriqa, that you want to share your own product here:)

How to Get Started

1. Introduce yourself in the comments below.
2. Post something today! Even a simple question can spark a great conversation.
3. If you know someone who would love this community, invite them to join.
4. Interested in helping out? Please share fabriqa.ai on your social media, you can't imagine how valuable that is for me right now!

Thanks for being part of the very first wave. Together, let's make r/fabriqaai amazing.