A self-hosted bug bounty research agent. Go backend, React dashboard, one binary.
CrySec is an autonomous security research agent for bug bounty hunting, exploit development, smart contract auditing, and recon. It reads and writes files, runs shell commands, drives a real browser, searches the web, remembers what matters across sessions, schedules its own work, and answers from Telegram and Discord, all from a single process you run on your own machine.
crysec # terminal UI
crysec serve # start API + dashboard in the background on :8787
crysec status # show the background server status
crysec stop # stop the background server
crysec setup # configure it, in the browser or the terminal
Note
CrySec is an early release. It runs and is used daily, but the surface is still moving and rough edges are expected. Bug reports, feature ideas, and pull requests are all welcome, open an issue or send a PR. See Contributing.
Runs on Linux, macOS, and Windows.
- 6-phase bug bounty workflow, SCOPE, RECON, ANALYZE, VERIFY, REPORT, TRIAGE
- Browser automation, real Chromium via DevTools, drives actual web pages
- Memory & RAG, durable facts across sessions, hybrid search + rerank
- VPS management, live CPU/RAM/disk, process lists over SSH
- Soul identity, give the agent a name and personality via SOUL.md
- Cron scheduler, agent runs tasks on a schedule
- Multi-channel, Telegram, Discord, Slack gateway support
- Intercept proxy, MITM HTTP/HTTPS traffic for analysis
- OSINT tools, email, domain, subdomain reconnaissance
- MCP integration, connect to any Model Context Protocol server
| Decision | Reason |
|---|---|
| Go backend, no framework | One static binary, no runtime to install, low idle memory. |
net/http routing |
Go 1.22 method + pattern routing covers every route here. |
| Pluggable storage | SQLite for a single node, Postgres when you outgrow it, same code. |
| Dashboard embedded in the binary | make build produces one file to copy anywhere. |
| Hand-rolled WebSocket client | The Discord gateway is the only consumer; a small internal/wsutil beats a dependency. |
Dependencies are deliberately few: a YAML parser, two database drivers. Everything else is the standard library.
The installer downloads the prebuilt binary for your platform from GitHub Releases, no build tools required. Full guide, per-OS notes, and troubleshooting: docs/installation.md.
Linux / macOS
curl -fsSL https://raw.githubusercontent.com/dimasdew/crysec/main/scripts/install.sh | bashWindows (PowerShell)
irm https://raw.githubusercontent.com/dimasdew/crysec/main/scripts/install.ps1 | iexWhile the repo is private, install the GitHub CLI and run
gh auth loginfirst, the installer uses it to fetch release assets. Once the repo is public this is not needed.
From source (to develop, or run an unreleased commit, needs Go 1.21+, Bun/npm, git):
git clone https://github.com/dimasdew/crysec.git
cd crysec
make install # Go modules, Air, frontend packages
make build # single binary with the dashboard embedded
./bin/crysec # first run drops straight into setupSetup asks how you want to configure it:
1 Browser , a guided page in the dashboard
2 Terminal , a few questions right here
Both write the same ~/.crysec/config.yaml, so pick whichever is in front of
you. On a headless box the browser option prints every address the setup page is
reachable on, so you can finish from a laptop on the same network.
For development, run both servers with hot reload:
make dev # backend (Air) + frontend (Vite)- Dashboard: http://localhost:5173
- API: http://localhost:8787
Production build:
make build # to bin/crysec, dashboard embedded
./bin/crysec serve # starts in the backgroundUse crysec serve --foreground when running under systemd, Docker, or while
debugging and you want the server attached to the current terminal. Daemon logs
are written to ~/.crysec/logs/daemon.log.
Both dev servers bind 0.0.0.0, so a private-network address works directly:
http://<tailscale-ip>:5173 # dev
http://<tailscale-ip>:8787 # production binary
CrySec leaves the dashboard open when server.auth_token is empty, which is the
right default behind a private network. Set the token to require a bearer token.
Everything lives in ~/.crysec/config.yaml, editable from the dashboard, the
CLI, or the file itself. Environment variables override the file; ~/.crysec/.env
is loaded automatically.
crysec config get model.default
crysec config set model.default anthropic/claude-sonnet-4.5
crysec config path| Key | Meaning |
|---|---|
model.default / model.provider |
Which model answers |
providers.* |
Endpoints and API keys |
database.driver |
sqlite, postgres, or memory |
tools.toolset |
Which tools the model gets: minimal, coding, research, default, all |
rag.embed_provider / rag.rerank_mode |
Native retrieval: embeddings (voyage, openai, custom) and rerank (llm, api, off) |
gateway.telegram / gateway.discord |
Messaging bots |
tools.browser |
The real-browser tool: executable, viewport, headed mode, stealth |
tools.http |
The http_request tool: browser-fingerprinted API calls, proxy |
agent.verify_replies |
Check a finished answer against the request before showing it |
Any OpenAI-compatible endpoint works out of the box; Anthropic and Gemini have native adapters so reasoning, prompt caching, and vision behave correctly.
| Provider | Kind | Notes |
|---|---|---|
| OpenRouter | openai-compatible |
Default. Model ids stay slash-qualified. |
| OpenAI | openai |
|
| Anthropic | anthropic |
Extended thinking, prompt caching |
| Google Gemini | gemini |
Thinking budgets |
| Ollama / LM Studio / vLLM | openai-compatible |
Point base_url at the local server |
| Anything else | custom |
Set base_url and api_key |
database:
driver: sqlite
dsn: ~/.crysec/crysec.dbdatabase:
driver: postgres
dsn: postgres://user:pass@localhost:5432/crysec?sslmode=disableSQLite uses FTS5 for conversation search; Postgres uses tsvector. Both are
created automatically on first run.
Tools. File read/write/edit, directory listing, glob, regex search, a persistent shell (working directory and environment survive between calls), a real browser, web search and fetch, long-term memory, cross-session search, semantic retrieval, task lists, skill authoring, and sub-agent delegation.
A real browser. CrySec drives an actual Chromium over the DevTools protocol, no driver binary and no Node. Pages are described rather than screenshotted: a snapshot lists what a person could act on, each with a reference the model names to click or type into. The page persists between tool calls, so a login holds while the agent keeps working. For sites behind a bot-detection challenge, a stealth mode launches a source-patched, signature- verified Chromium that passes them. See docs/browser.md.
Fingerprinted HTTP. For APIs rather than pages, http_request calls
endpoints with a real browser's TLS and HTTP/2 fingerprint (JA3/JA4, HTTP/2
settings, header order), so services that reject a stock HTTP client at the
handshake still answer. See docs/http.md.
Specialist roles. The agent is a team of specialists, not one generalist, a reviewer that only reads, a researcher that only browses, a report writer that
only writes. /role runs a conversation as one; the agent delegates a piece of
work to the specialist suited to it. Thirteen ship, including a security set for
authorized penetration testing, gated on a scope you control. See
docs/roles.md.
Slash commands. /status, /model, /skills, /goal, and two dozen more
work identically in the terminal, in the web chat, and in a Telegram or Discord
thread, because all three dispatch through one definition. The web composer
completes them as you type. See docs/commands.md.
A hub. Skills and MCP servers have a browsable catalogue with one-click
install. Eight skills ship inside the binary; beyond those, a skill can come
from any public GitHub repository or any URL serving a SKILL.md. Installed
skills are scanned first, a skill is prompt text the model follows, so one that
pipes a download into a shell is refused rather than quietly obeyed. See
docs/hub.md.
A harness that survives long work. A repetition guard catches a model calling the same thing with the same arguments and tells it to change approach. Steering delivers an instruction typed while a run is already going. Optional verification runs a second model over a finished answer to catch work that was described but not done. Standing goals outlive a turn: a judge decides whether the goal is really met and, if not, names the next step. See docs/harness.md.
Memory. The agent decides what is worth keeping and writes it to durable
storage. Memories are injected into the system prompt on every turn, bounded by
memory.memory_char_limit.
RAG. Fully native, in-process, no external daemon. Embeds with your
configured provider (Voyage, OpenAI, or any compatible endpoint), stores vectors
in the CrySec database, and runs a four-stage pipeline: hybrid recall (dense +
lexical) to rerank (Voyage/API when available, else an auxiliary model, else off)
to near-duplicate compression to top-k. With auto_context on it indexes each
conversation and pulls relevant knowledge into every turn; a project session can
index its whole folder and keep it fresh as files change.
Skills. Markdown files with YAML front matter in ~/.crysec/skills. The
agent writes its own after solving something non-obvious; the catalogue (names
and descriptions only) goes in the prompt, and full bodies are fetched on demand
so the context stays small.
Scheduling. A five-field cron parser plus @daily/@every 90m shorthands.
Jobs are natural-language prompts that run unattended and can deliver their
output to a messaging channel.
Messaging. Telegram (long polling, no public domain needed) and Discord (websocket gateway). Both share the same sessions, memory, and tools, and both gate access behind an allow list or a pairing approval flow.
MCP. External Model Context Protocol servers over stdio or streamable HTTP.
Their tools are namespaced mcp__<server>__<tool> and made available to the
model automatically; a server that fails to start is reported, never fatal.
Two interfaces. A full-screen terminal UI (crysec) and a web dashboard
(crysec serve) over the same agent, sessions, and memory. The TUI has a
multiline composer, slash-command completion, live tool output, history recall,
scrollback, and Ctrl+C interrupt. Run /help inside it for the full list.
Context compaction. As a conversation approaches the model's context window, older turns are summarised while recent ones stay verbatim, and tool-call turns are never split from their results.
cmd/crysec/ CLI entry point
internal/
agent/ conversation loop, tool dispatch, compaction, delegation
llm/ provider adapters (openai, anthropic, gemini, compatible)
tools/ the callable tool surface and toolsets
store/ Store interface + SQLite/Postgres implementation
rag/ retrieval backends
skills/ the skill library
cron/ schedule parser and runner
gateway/ Telegram and Discord adapters
mcp/ Model Context Protocol client
browser/ Chrome DevTools Protocol client and page control
hub/ skill and MCP catalogue, and the installers
commands/ slash commands, shared by every surface
tui/ the terminal interface
server/ HTTP API and dashboard hosting
wsutil/ minimal RFC 6455 client
config/ layered configuration and its schema
web/ React dashboard (Vite, Tailwind, shadcn-style, Phosphor)
The dashboard owns its layout centrally: web/src/lib/routes.ts declares every
page, and AppShell renders the container and header, so pages contain content
only. The interface ships in English, Indonesian, Japanese, Chinese, and Russian.
make dev # backend (Air) + frontend (Vite), both hot-reloading
make dev-api # backend only
make dev-web # frontend only
make check # go vet + go test + tsc
make smoke # load every dashboard route in a real browser
make build # single binary with the dashboard embedded
make doctor # diagnose configuration and connectivitymake smoke exists because two of the worst bugs so far passed every type
check: a hook called from inside an effect, and the server bouncing SPA routes
to ./. Both blanked the entire dashboard. Loading each route in a real browser
catches that class of failure; nothing static does.
crysec doctor checks the config file, workspace, database, provider
credentials, and RAG backend in one pass.
| Guide | What it covers |
|---|---|
| Installation | Install on Linux, macOS, Windows; upgrading; releases |
| Getting started | First run, connecting a provider |
| Configuration | Every setting, and where it can be set |
| Tools | The tool surface and the toolsets |
| Browser | Driving a real browser |
| HTTP requests | Calling APIs with a browser TLS fingerprint |
| Roles | Specialist agents, delegation, and authorized security testing |
| Skills | Writing, installing, and learning skills |
| Hub | The skill and MCP catalogue |
| Plugins | Hooks for external programs |
| Sandboxing | Confining what commands can reach |
| Commands | Every slash command |
| Harness | Goals, steering, verification, repetition guard |
| Memory and RAG | What is remembered, and retrieval |
| Channels | Telegram and Discord |
| Scheduling | Cron jobs and delivery |
| MCP | External Model Context Protocol servers |
| HTTP API | Every endpoint |
| Deployment | Running it as a service |
| Backups | Archiving and restoring everything |
| Architecture | How the pieces fit |
| Development | Building and testing |
CrySec is an early release and actively worked on, contributions are welcome.
- Bugs & ideas: open an issue.
Include what you ran, what happened, and
crysec doctoroutput where it helps. - Pull requests: send one. Run
make check(go vet + tests + tsc) before pushing; for dashboard changes,make smokeloads every route in a real browser. - Scope: the interface is still moving, so for anything large it is worth opening an issue first to agree on the shape.
Because it is early, expect rough edges and the occasional breaking change between versions. Please report anything that surprises you.
Apache License 2.0. You may use, modify, and distribute CrySec, including commercially; in return, keep the license and attribution notices, mark any files you change, and note that the license includes an express patent grant that terminates for anyone who brings a patent claim against the project.