The fastest way to set up AgentBeam is to ask your coding agent to do it. AgentBeam ships two skills for exactly that: agentbeam-setup and agentbeam-app-monitoring. One npx command installs a skill for every coding agent on your machine, and Beam scans the skill before it installs. This post shows the commands, what each skill covers, how to prompt your agent, and how to review what it does.
| Question | Short answer |
|---|---|
| How do I install a skill? | npx @agent-beam/beam add skill <name> -g --all-agents |
| Which skills are there? | agentbeam-setup and agentbeam-app-monitoring |
| Is the skill checked first? | Yes, Beam scans the skill before installing |
| Do I still review things? | Yes. Read the commands your agent proposes |
| Where do I get a token? | The App monitoring page in the dashboard |
What a skill is, and why install one
A skill is a bundle of instructions and helper files that a coding agent loads when a task matches. Instead of you reading documentation and typing commands, the agent reads the skill, asks you for what it is missing, and does the work in your repository. For a task with many small steps, such as installing a CLI, creating a config and adding a CI job, that saves real time.
It also changes the trust question. A skill is text your agent will follow, which is exactly the shape of input prompt injection abuses. That is why installing one from a source you have not looked at is a risk, and why AgentBeam scans skills in the first place. The same scanner that checks third-party skills runs before these two install.
Install the skills
Install agentbeam-setup first:
npx @agent-beam/beam add skill agentbeam-setup -g --all-agents
Then the skill for app monitoring:
npx @agent-beam/beam add skill agentbeam-app-monitoring -g --all-agents
What the flags mean:
-ginstalls the skill globally, so it is available in every project and not only the current directory.--all-agentsinstalls it for every supported coding agent it finds on the machine, so you do not need to repeat the command per tool.
Before anything is written, Beam scans the skill. The scan is heuristic: it looks for patterns such as credential access, destructive commands and instructions aimed at the model, and it reports what it found. Read the report. A scan reduces risk, and it is not a guarantee, which is true of any heuristic check.
What agentbeam-setup covers
agentbeam-setup is for getting AgentBeam itself running. When you ask your agent to set up AgentBeam, it follows the skill to:
- install the
beamCLI, - connect it to your AgentBeam workspace,
- wire up the agent hooks so the activity of your coding agents is recorded.
If you have never used AgentBeam, start here. The AI agent monitoring page explains what the hooks capture once they are in place.
What agentbeam-app-monitoring covers
agentbeam-app-monitoring is for the application you are building or running. It walks your agent through the steps in Monitor a running app for attacks with beam monitor:
- Adding the app in the dashboard and handling its
BEAM_APP_TOKEN. - Running
beam monitornext to the app, or piping logs in with--stdin. - Confirming with
beam monitor testandbeam monitor status. - Adding
beam cve check .to CI, as described in Check dependencies against known CVEs in CI.
The agent is useful here because every app is a little different. Where your logs go, how your service starts and which CI system you use all vary. An agent that can read your repository can adapt the steps, where a copy-paste snippet cannot.
Prompts that work
Be specific about the outcome and the boundaries. For example:
Set up AgentBeam app monitoring for this repo using the agentbeam-app-monitoring
skill. Use the app name "bgremover". Do not paste the token anywhere in the repo:
read it from the BEAM_APP_TOKEN environment variable. Add a CI job that runs
beam cve check . and show me the diff before committing.
A few habits make this go well:
- Name the app yourself. The dashboard needs a name for each app, and you know it better than the agent does.
- Give the token a safe path. Create the app in the dashboard and set
BEAM_APP_TOKENin your shell or CI secrets. Do not have the agent write it into a file. - Ask for a diff, not a commit. You review, then you commit.
- Ask it to run the test.
beam monitor testsends one test finding end to end, so a working setup is proved and not assumed.
Review what the agent does
Letting an agent set up a security tool is a reasonable use of agents, and also a good moment to practice the discipline you want from them. A few checks take a minute:
- Commands. Read each command before approving it. Setup should install a package, set environment variables and edit a CI file. It should not need to touch unrelated directories.
- Secrets. Search the diff for the token. It should appear as a variable name, never as a value.
- Outbound connections. App monitoring talks to AgentBeam over HTTPS. Anything else in a setup change deserves a question.
- CI permissions. Adding a job should not widen the permissions of existing jobs.
Per-app tokens are built to make a mistake here cheap. They are least-privilege and only accepted by the App monitoring endpoints. They are stored hashed and shown once, and you can rotate or revoke them. If a token ends up in a transcript or a log, revoke it and create another.
What to expect afterwards
Once the setup finishes, you should have a monitored app, a test finding in your dashboard and, if you added it, a CI check that fails on vulnerable dependencies. From there:
- Choose the level (Light, Standard or Strict) in the dashboard.
- Add a Slack or Discord webhook, or a signed-JSON webhook, with the minimum severity you want.
- Decide whether to turn on the optional LLM second opinion, using your own OpenAI-compatible model through the
BEAM_LLM_*variables or Beam's model from the dashboard.
Remember what the monitor is: it only watches, it never blocks requests, and its detection is heuristic. Your agent can wire it up, and it cannot make it a firewall.
A walk-through of a typical session
It helps to know what a good session looks like, so you can tell when one goes sideways.
You start with a plain request: set up app monitoring for this repository. The agent loads agentbeam-app-monitoring and begins by asking for what only you can supply: the app name, and confirmation that you have created the app in the dashboard and set BEAM_APP_TOKEN in your environment. It should not ask you to paste the token into the chat. If it does, answer with the variable name instead.
Next the agent inspects the repository. It looks at how the app starts and where it writes logs, because that decides whether the monitor reads files or takes piped output through --stdin. It proposes the start command change or a small service definition, and you read it. It then proposes a CI job that runs beam cve check ., and you read that too.
Finally it runs the proof: beam monitor test to send one test finding, then beam monitor status to show the app, level and usage. You check the dashboard for the test finding. If it is not there, the usual causes are a wrong or revoked token, an outbound HTTPS connection that is blocked, or the app not being turned on in the workspace. A good session ends with a visible test finding and a small, reviewable diff.
Warning signs are just as clear. The agent edits files unrelated to monitoring, asks for the token in plain text, adds a step that downloads and runs a script from a URL you have not seen, or widens permissions on existing CI jobs. Stop the session and look at what the skill actually said. If a skill ever instructs your agent to do something that does not match its stated purpose, treat that as a finding and report it.
Why scan a skill at all
Skills are attractive targets because they sit between you and a tool that can run commands. A malicious or compromised skill can hide an instruction such as sending your environment variables to a remote host, in prose that looks like documentation. Because the agent is built to follow instructions, it may simply comply.
That is the reason add skill scans before it installs. The scan is heuristic and it looks for the shapes these instructions take, such as credential references, destructive commands and text aimed at the model. A clean scan lowers your risk, and a flagged one gives you something specific to read before you decide. It does not make an untrusted skill trustworthy, so the rule stays the same for every skill you install: know where it came from and read what it will make your agent do.
Setup skill or manual steps: which to choose
Use the skills when you set up many repositories, when your stack differs from the documentation's examples, or when you simply prefer to review a diff over typing commands. Use the manual steps when you want to understand each piece the first time, when your environment restricts what an agent may run, or when a change must go through a formal review. Neither path is more secure by itself. What protects you is the same in both cases: a scoped, revocable token, a reviewed diff and a test finding that proves the path works end to end.
Requirements
App monitoring needs an AgentBeam workspace with it turned on by an owner or admin, and usage counts toward a monthly allowance that depends on your plan. The getting-started link works whether or not you already have an account. The App monitoring docs have the full reference.
Summary
Two commands install the skills. Beam scans each skill before installing it, your agent does the repetitive work, and you review the diff and keep the token out of the repository. If you want the manual version first, read the beam monitor guide, or see the app monitoring solution page for the overview. The CLI is open source under AGPL-3.0 at github.com/whyashthakker/beam-cli.
Frequently asked questions
How do I install the AgentBeam skills?
Run npx @agent-beam/beam add skill agentbeam-setup -g --all-agents, and the same command with agentbeam-app-monitoring. The -g flag installs globally and --all-agents installs for every supported coding agent on the machine.
What does agentbeam-setup do?
It gives your coding agent the steps to set up AgentBeam itself: install the CLI, connect it to your workspace and wire up the agent hooks, so you can ask your agent to do the setup instead of following docs by hand.
What does agentbeam-app-monitoring do?
It teaches your coding agent how to set up app monitoring for your application: add the app, configure BEAM_APP_TOKEN, run beam monitor next to the app, and add a beam cve check step to CI.
Is it safe to let an agent install skills?
Beam scans a skill before installing it, and you should still read what it will do. A skill is a set of instructions your agent follows, so treat an unreviewed skill like an unreviewed script.
Will the agent see my token?
It may, if you paste it into the session. Per-app tokens are least-privilege and rotatable, but keep them out of prompts where you can, set them as environment variables or CI secrets, and revoke one that was exposed.
Do the skills need an AgentBeam account?
App monitoring needs an AgentBeam workspace with it turned on by an owner or admin. The getting-started link works whether or not you have an account.
Details are accurate as of October 23, 2026.