DeepCerebra Coder is an agentic coding assistant. Unlike a plain autocomplete copilot, it plans, writes, refactors, runs commands, calls tools, and iterates across your whole project — with you reviewing and approving the changes it proposes.
| Edition | Best for | File access |
|---|---|---|
| Web app | Zero-install, work from any machine | Confidential in-browser storage (and Git repos) |
| Desktop (Windows / Linux / macOS) | Local-first development, local models | Direct local file system |
| CLI & API | Scripting, CI/CD, automation | Local files / programmatic |
This guide focuses on the web app at deepcerebra.ai; the desktop app mirrors the same panels and workflows.
Use a current version of Chrome, Edge, or Brave for the full experience — opening a local folder relies on the Chromium File System Access API. Firefox and Safari work for chat and for Git-backed projects, but cannot open a local folder directly.
/register?plan=basic (or pro / ultimate), or start now and pick a plan
later in Billing.After signing in you land in the workbench, which puts every pane in one screen:
Drag the splitter between the editor and chat to rebalance the layout, and drag the horizontal splitter to resize the terminal. The left sidebar also navigates to Workspace, Extensions, API Keys, Billing, and Feedback.
repo scope (classic) or a fine-grained token with Contents + Pull requests; for
GitLab use the api scope. Your token is stored on the server — only file contents are pulled
into the browser.owner/name (filter the list to find yours), then pick a
branch.dcc/my-feature) to keep your
work isolated from the default branch.Chat history is tied to the open project. Switching folders automatically starts a new session and loads that folder's previous sessions, reopening the most recent so you can resume where you left off.
Folders DeepCerebra uses internally — .deepcerebra, .sessions — appear in the tree
but are collapsed by default so they don't clutter your source.
Describe what you want in plain language — ask a question, request a feature, or point at a bug. Be specific about files, frameworks, and constraints to get the best result. Attach relevant files by dragging them into the prompt.
Responses are organized like Cursor: the agent's reasoning is separated from the deliverable. Each response block has a copy icon in its upper-right corner so you can copy a finished report, document, or a command you're meant to run.
lxml instead of html.parser") to break the agent out of a
loop.@deepcerebra, and prefixes like [deep] request deeper reasoning.Pick a mode from the mode selector next to the prompt. Each tunes how much the agent plans and how freely it edits:
| Mode | What it does | Use when… |
|---|---|---|
| Agent | Plans and edits across your project autonomously | You want the assistant to implement a change end-to-end |
| Ask | Answers questions about your code without editing | You want to understand the codebase |
| Plan | Drafts an approach before any editing | The task is large or has trade-offs to settle first |
| Edit | Makes focused edits in the current context | You want a small, targeted change |
When the agent proposes file changes, a Proposed Changes panel appears above the chat input, listing each touched file with added (+) and removed (−) line counts.
applied (and · disk when written to a real folder).Toggle the terminal beneath the editor to run builds, tests, and scripts. With your authorization, the agent can execute commands and read their output to verify its work; long-running commands stream output so you can watch progress. Close the terminal from its header when you don't need it.
For larger goals, use Plan mode (or ask the agent to plan first). The planner scans your project, decomposes the goal into dependency-aware tasks, and assigns each to the right specialist (architect, coder, tester, docs).
Open the model picker next to the prompt. Options are grouped as:
On Auto, DeepCerebra uses tiered, adaptive routing: simple tasks go to a fast, economical model, while complex or planning-heavy work (for example, Plan mode) is routed to a stronger model. This balances cost and quality automatically, so you rarely need to choose manually.
You can route requests through your own provider account instead of metered platform usage.
ANTHROPIC_API_KEY,
GOOGLE_API_KEY, OPENAI_API_KEY).Platform (DeepCerebra) models need no key. Remove a key any time with Remove.
The DCC Bridge connects your own computer to the web app through a small
dcc-bridge connector, unlocking two capabilities at once:
The connector dials out over an authenticated WebSocket — no inbound ports needed, and it works behind NAT and firewalls. It runs on Windows, macOS, and Linux (Python 3.10+).
dcc_brg_…)
and the ready-to-paste connector command — the token is shown exactly once.pip install git+https://github.com/mohammadkhair7/DeepCerebra-connector
# then run the command copied from the pairing card, e.g.:
python -m dcc_bridge --gateway wss://deepcerebra.ai --token dcc_brg_xxxxxwss://deepcerebra.ai or wss://deepcerebra.io) — the pairing card prefills the
right one. The two sites are separate deployments with separate accounts and tokens.1234) with a model loaded.By default, commands are confined to a dedicated workspace folder (~/DeepCerebra). To work in
your real project folders with your pre-configured CLIs, grant them explicitly when starting the connector:
# grant one or more real folders (repeatable)
python -m dcc_bridge --gateway wss://deepcerebra.ai --token dcc_brg_xxxxx --host-dir "F:\MyProjects"
# or the whole machine (prints a warning; prefer --host-dir)
python -m dcc_bridge ... --allow-any-dirThen open the Terminal panel, click the Execution target popover (laptop icon), choose My computer, and pick a working directory. Both your typed commands and the agent's build/test commands are then executed on your machine.
--no-exec makes a
device inference-only (GPU models, no commands).With a Git-backed project open, a branch bar appears in the Explorer showing your current branch and two actions:
main). You must be on a working branch, not the default branch.If the push webhook is enabled, the Explorer auto-refreshes when teammates push, keeping everyone in sync — the foundation for collaborative team development through DeepCerebra.
Extend the agent with external tools and data via the Model Context Protocol. Configure
servers in a .deepcerebra/mcp.json file, for example:
{
"mcpServers": {
"my-tools": {
"url": "https://example.com/mcp",
"disabled": false,
"allowlist": ["search_issues", "get_pr"],
"autoApprove": ["create_issue"],
"auth": { "type": "bearer", "tokenEnv": "MY_TOKEN" }
}
}
}Enabled MCP tools become available to the agent automatically when they're relevant to your request. Local
(stdio) and remote (http/sse) servers are both supported.
allowlist, only those tools can run.autoApprove.If a server exposes MCP resources or prompt templates, the agent
automatically gains tools to use them (mcp_list_resources, mcp_read_resource,
mcp_list_prompts, mcp_get_prompt).
Add an auth block to a remote server. Secrets support ${ENV_VAR} interpolation:
// Static bearer token (literal or from env)
"auth": { "type": "bearer", "token": "${GITHUB_TOKEN}" }
"auth": { "type": "bearer", "tokenEnv": "GITHUB_TOKEN" }
// Custom header (e.g. API key)
"auth": { "type": "header", "header": "x-api-key", "value": "${MY_KEY}" }
// OAuth 2.0 client-credentials
"auth": {
"type": "oauth", "grant": "client_credentials",
"tokenUrl": "https://auth.example.com/oauth/token",
"clientId": "${MCP_CLIENT_ID}", "clientSecret": "${MCP_CLIENT_SECRET}",
"scope": "mcp.read mcp.write"
}You can shape how the agent thinks and acts with a single, file-based convention — the
.deepcerebra/ directory — that works identically in the desktop app, the
web app, and the API. In the web app, manage all of these under the
Agent view; on desktop and via the API they are plain files you commit with your project.
Configuration is discovered from several scopes; when the same item exists in more than one, the higher-precedence one wins:
team/org < global (~/.deepcerebra) < workspace (<repo>/.deepcerebra)
(lowest) (highest)<repo>/.deepcerebra/…, committed with the project.~/.deepcerebra/…, your personal defaults across projects.Rules are persistent instructions — coding standards, architecture conventions, domain context — injected into
the agent's system prompt. They live as Markdown files under .deepcerebra/steering/, plus the
always-on AGENTS.md standard. Frontmatter controls when a rule loads:
---
inclusion: fileMatch # always | fileMatch | auto | manual
globs: "src/**/*.ts" # or fileMatchPattern
name: api-design
description: REST conventions
---
# API design
- Use REST resource nouns, plural.always — every turn (the default).fileMatch — only when an in-context file matches globs.auto — when your request matches the rule's name/description.manual — only when you reference it as #name or /name.A root AGENTS.md applies repo-wide; a nested AGENTS.md (e.g.
services/api/AGENTS.md) applies only to files under that folder. In the web app, the
Agent → Steering view gives each rule a Scope picker
(Global / Project / Team).
Skills are reusable playbooks the agent loads on demand. Each skill is a folder with a
SKILL.md under .deepcerebra/skills/:
---
name: deploy-release
description: How to cut and publish a versioned release.
disable-model-invocation: false # true => manual-only (/skill)
---
# Deploy a release
1. Bump the version, build, and test.
2. Tag and publish.The agent sees a lightweight catalog (name + description) and pulls in the full body with the
load_skill tool when relevant. You can also invoke one explicitly with
/skill <name>. Set disable-model-invocation: true to make a skill manual-only.
Hooks run automation on lifecycle events. Define them as .deepcerebra/hooks/*.hook.json:
{
"title": "Format on save",
"event": "fileSave",
"filePattern": ["**/*.ts"],
"action": { "type": "shell", "command": "npm run lint:fix -- $FILE" },
"enabled": true
}Events include promptSubmit, preToolUse, postToolUse,
fileCreate, fileSave, fileDelete, preTask,
postTask, sessionStart, preCompact, and agentStop
(Cursor/Claude spellings are also accepted). An action is either shell (run a command) or
agentPrompt (ask the agent). A preToolUse hook can allow,
deny, or ask for the tool call it intercepts.
Subagents are specialist agents you define and delegate to. Each is a Markdown file under
.deepcerebra/agents/ with frontmatter plus a body (its system prompt):
---
name: security-reviewer
description: Audits a diff for security issues; read-only.
model: gpt-5
readonly: true
tools: [read_file, grep_files, list_directory]
background: false
---
You are a meticulous security reviewer…The main agent delegates with task (blocking), task_async +
task_status / task_result (background), or task_parallel (fan-out).
A plugin bundles rules, skills, hooks, subagents, and MCP servers into one installable package under
.deepcerebra/plugins/<name>/, described by a plugin.json manifest:
{
"name": "Acme Standards",
"version": "1.2.0",
"description": "Acme rules + skills + review agents.",
"enabled": true
}Plugin contents are merged at the lowest precedence, so your own rules and skills always override a plugin's.
Disable a plugin with "enabled": false or a .disabled marker file.
DCC_ORG_CONFIG_DIR at a shared .deepcerebra directory, or by setting rules to the
Team scope in the web app.The Workflow Studio is a visual designer for multi-agent automation. You compose stages — each an agent, a specialist step, or a control primitive — into a graph, connect them with dependencies, and run the whole orchestration on the engine with live per-stage progress, budgets, and human-approval gates. Workflows are saved as a portable YAML/JSON definition you can export, import, version in Git, and run from the API or CLI.
| Stage kind | What it does |
|---|---|
agent | One agent turn with the skills and tools you attach. |
spec.requirements / spec.design / spec.execute |
Spec-first delivery: draft requirements, design, then break into tasks and execute — each gateable. |
documents.generate | Produce a polished document from prior stage outputs. |
fan_out | Parallel wide-research across many subtopics with synthesis. |
map / loop / switch |
Control primitives: run a body per item, repeat until a condition, or branch across cases. |
verify / browser_verify |
Run tests or commands in the sandbox; verify a running UI with browser automation. |
orchestrate | Dynamic routing: an orchestrator agent reads the request and dispatches it to the best downstream agent(s) over events. |
external.agent | Call a registered third-party agent over HTTP (A2A) as if it were a native stage. |
eval | Score an upstream output against checks (contains / regex / length / LLM-judge); fail below a threshold. |
db.provision | Generate an owned data layer: docker-compose for the database,
versioned SQL migrations, seed data, .env template, and a Mermaid ERD; optional auth scaffold;
can apply migrations to SQLite immediately. |
ci.generate | Generate a ready-to-commit CI/CD pipeline (GitHub Actions, GitLab CI, or Azure Pipelines) with lint → test → scan → build → deploy and environment promotion. |
deploy.package | Generate production deployment assets: multi-stage Dockerfile, docker-compose, Kubernetes manifests, or a Helm chart — files you own and commit. |
test.generate | Generate unit / API / E2E suites for the built app plus a requirement-to-test traceability matrix. |
test.verify | Execute a test suite (pytest, vitest, jest, Playwright) and gate the run on its pass rate. |
security.audit | Scan dependencies for known vulnerabilities and the tree for hard-coded secrets; publishes alert events and writes a findings report. |
preview | Start the generated app locally and surface its live URL in the run
panel (link + inline frame) via a preview.ready event. |
design.import | Turn a UI design image (screenshot, mockup, Figma export) into a structured implementation spec for downstream stages. |
Every stage — regardless of kind — can publish and subscribe to typed events on the workspace event bus, so agents coordinate like services on a message fabric rather than only through the DAG:
lifecycle, agent,
business, data, system, schedule, chat,
external, or alert — filterable in subscriptions and replay.trigger (the stage runs when a matching event arrives; a
run with parked stages stays resident as listening), gate (a machine gate approved by
an event instead of a human click), and data (the payload is merged into the stage's
context).agent.<stage-id>.request.triggers: block arms it to start on inbound
webhooks, cron schedules, events, or chat — even while the
Studio is closed.Agents that react to events can declare a durable named queue so matching events are never
lost while the agent is busy or before a run is listening. On a trigger subscription, set
queue: <name> — the engine binds that topic to a FIFO queue on the workspace event bus
(persisted under .deepcerebra/workflows/events/queues/). Every matching event published from that
point on is captured into the queue; when the stage becomes runnable, the engine pops events in
oldest-first order and consumes them one at a time.
count — require N queued (or delivered) events
before the subscription is satisfied (useful when several workers must report in).GET /api/workflow/queues lists depth and bindings;
GET /api/workflow/queues/{name} peeks pending events; chat agents can call
event_queue_status and pop_queued_event.events:
subscribe:
- topic: ticket.created
mode: trigger
queue: triage-inbox # durable FIFO — events wait here for this agent
map:
payload.ticket_id: ticket_idA semaphore limits how many tasks may simultaneously operate on a shared (protected) resource:
a database being written, a global variable store, a file, or a rate-limited external agent. Attach one to any
stage with semaphore: — before the stage's work runs, the engine acquires one permit of the named
workspace semaphore; the permit is always released afterwards, even if the stage fails.
permits: 1 makes it a mutex: only one task at a time (across all parallel runs in
the workspace) executes the critical step; every other task waits until the holder finishes.
timeout_s for a permit; if the
resource stays at capacity, the stage fails visibly instead of hanging forever.ttl_s; if a holder crashes without
releasing, the permit auto-expires so the resource is never dead-locked.semaphore.<name>.waiting,
.acquired, and .released system events; GET /api/workflow/semaphores
shows capacity, holders, and available permits.acquire_semaphore, release_semaphore, and
semaphore_status tools coordinate ad-hoc critical sections outside a workflow.semaphore:
name: emr-db-writer
permits: 1 # mutex — one writer at a time
timeout_s: 300 # fail if still waiting after 5 minutes
ttl_s: 900 # auto-release crashed holders after 15 minutesRendezvous waits until multiple event conditions are all met before the next step
proceeds — the opposite of "first event wins." Set join: all on the stage's events:
block: every trigger subscription must be satisfied before the stage runs. Combine with
per-subscription count: N when several agents (or several reports from one agent) must all check
in — for example, design sign-off, test completion, and security approval before a release stage executes.
join: any (default) — the stage runs when the first trigger subscription is
satisfied.join: all — rendezvous: each trigger subscription (each with its own topic,
class filter, and optional count) must be satisfied; only then does the stage become runnable.trigger_events
and exposed to templates as inputs.events (a list of event objects with payloads).events:
join: all # rendezvous — wait for EVERY subscription below
subscribe:
- topic: design.approved
mode: trigger
- topic: tests.passed
mode: trigger
- topic: security.cleared
mode: trigger
count: 1Stages pick tools from the same registry the chat agent uses:
create_database, apply_migrations, and dump_schema for owned data
layers.docker_build / docker_push, compose up/down, SSH and
cloud-CLI deploys (Fly, Render, Railway, Vercel), also simulation-safe.Class.method) across mathematics, signal processing, controls, statistics, and more./v1 API exposes runs, events, triggers, templates, and generation for CI and integrations.db.provision → implementation → generated tests → security audit → deploy packaging →
CI generation, with a human gate before packaging — a complete brief-to-production path you can adapt in
minutes.Predictive Tab completion offers inline, fill-in-the-middle code suggestions as you type in the editor — accept a suggestion with Tab. It is opt-in on both the engine and the web editor.
DCC_TAB_COMPLETE=1. The editor calls the
engine's POST /api/complete endpoint, which returns only the text to insert at the cursor.VITE_TAB_COMPLETE=1, or at runtime with
localStorage.setItem('dcc.tabComplete', '1') (then reload).Open Billing from the sidebar to manage your plan and usage. AI usage is metered in U.S.-dollar credits based on the tokens consumed by the underlying models.
| Plan | Monthly price | Included monthly AI usage |
|---|---|---|
| Basic | $20 | $10 |
| Pro | $75 | $30 |
| Ultimate | $200 | $150 |
A gateway API key (a personal access token) lets you use the DeepCerebra public API and CLI programmatically.
read, chat, code, agent
— and an optional expiry in days (blank = never).Use it with the CLI or the API at deepcerebra.ai:
dcc config set endpoint https://deepcerebra.ai
dcc config set api-key <your-key>
# or as a Bearer token
curl -H "Authorization: Bearer <your-key>" https://deepcerebra.ai/v1/...You can rename or delete (revoke) a key any time; each key shows its prefix, scopes, created/expiry, and last-used date.
Switch to Chrome, Edge, or Brave, or use Open from Git instead.
Click Stop, then rephrase with a concrete hint or constraint.
dcc-bridge connector is running and the device shows online.1234) with a
model loaded.--gateway
(wss://deepcerebra.ai or wss://deepcerebra.io) — the two sites are separate
deployments, and a token from one never works on the other.Open or create a working branch before using Integrate to open a pull request.
Still stuck? Contact support@deepcerebra.ai.
Discovery is an investigative chatbot for your databases and documents.
Instead of answering with a single query, it works like an analyst: it forms hypotheses,
runs a series of guarded probes (SQL, graph, document search, schema checks, web corroboration), prunes the
explanations the evidence refutes, and synthesizes a grounded answer — with charts and a
transparent cost receipt. Open it from the compass icon in the activity rail
(/app/discovery).
A Space bundles everything one line of questioning needs: database connections, document collections, instructions for the analyst, and budgets. Create one with + New space, then use the setup panel on the right to:
Type a question the way you would ask a colleague — for example "Why did MRI scan volume dip in March?". The investigation board streams the whole process live:
Follow-up questions continue the same thread, so the analyst keeps its context.
Charts render inline on the investigation board. Use Export to download the full ask — the answer, hypotheses, evidence, and charts — as a self-contained HTML report or a print-quality PDF, styled with the neon design system.
Each space carries per-ask budgets: a maximum number of probes, investigation rounds, seconds, and USD. The engine stops cleanly at the cap and reports what it found so far. Every probe's cost is itemized on the receipt, so you always know where the spend went.
/v1/discovery/* with a
PAT carrying the discovery scope (create it under Account → API Tokens).
Streaming asks use SSE. External executors can borrow just the investigative planning via the Thinking API
(/v1/think/*, scope think).pip install deepcerebra-discovery, then
DiscoveryClient(base_url, token).ask(space_id, question).discovery.ask) into any workflow to run an investigation as a pipeline step; the answer,
charts, and receipt flow to downstream stages.discovery_ask and
discovery_list_spaces as MCP tools, so external MCP clients can run investigations too.