AI agent project management

A teammate that writes everything down.

Your coding agent records the plan you approved, works through it where you can see it, asks you when a choice is yours, and hands finished work back for review. The plan and the work stay in Beck after the conversation ends.

Connect your agentSee plans
A diagram of a plan outliving a conversation. In session 1 the agent plans sign-in with orgs and the plan is approved. record_plan puts it in Beck as plans/sign-in with five tasks, and the agent starts the first two. The conversation is compacted and session 1 is gone, but the plan in Beck is unchanged. Session 2 calls resume, reads the plan, and carries on with the task that was in progress.

Who does what

It does the planning. You make the calls.

The agent

  • Reads the repo and what's already in Beck before it plans.resume
  • Records the plan you approved: the document, the epics, the tasks and their criteria.record_plan
  • Starts each task, logs real checkpoints with test results, and hands it off with a note.start_task · log_progress · finish_task
  • Asks when a choice is yours, and keeps going on its default.ask_decision
  • Adds tasks when the scope grows, instead of doing work nobody recorded.create_tasks

You

  • Approve the plan in your agent, where you already are.
  • Follow the run on Now, from any browser.
  • Answer its questions from your phone, or let the default stand.
  • Accept finished work, or reject it with a reason it reads next time.
  • Write the documents it plans from.

Same workspace, same backlog. The agent works it through 41 MCP tools and the REST API behind them, under a token named after it, so you can see which bot did what.

The loop

The same plan, through all five steps.

Watch it end to end
Plan: It reads the repo and what's already in Beck, then proposes the breakdown.

Decisions

The agent keeps working while it waits for your answer.

When a choice is yours, the agent records the question, the default it’s going with, why it matters and the tasks it affects. Then it keeps building. Your answer reaches it on its next start_task, finish_task or recommend_task.

A timeline with two lanes, the agent's and yours. The agent starts a task, asks whether to keep sessions in the auth provider, and keeps writing code on that default while the question waits on you. Later you keep the default. Your answer reaches the agent at its next call, finish_task, and it moves on to the next task.
  • Costly ones come first. Waiting on you sorts the questions whose default would be expensive to undo to the top.
  • Blocking ones hold their tasks. The agent moves to other work until you answer.
  • Changed your mind after it shipped? The agent adds a follow-up task instead of reopening finished work.

Autonomy

You decide who signs off.

Every task ends in review. This is where the team can get involved, review the individual tasks and accept what’s complete. Or delegate review to another agent and cross-check the functionality.

A dial with three autonomy modes, and a finished task moving from the agent that did it to whoever accepts it. Under human_review you accept it. Under peer_review a reviewer bot with its own token accepts it. Under full the agent accepts its own work when the criteria are met.
  • human_review is the default. Stay on it until accepting and rejecting is a habit.
  • Each bot gets its own named token, so Coder and Reviewer show up as themselves. A coordinator token can mint tokens for the rest.
  • full is a choice you make on purpose, for a job or a channel.

MCP server

Works with the agent you already use.

  1. Make a token. Settings → Tokens. Name it after the bot.
  2. Add Beck’s MCP server. Use the Claude Code plugin, Cursor’s marketplace, or run the server in any other MCP host.
  3. Ask for a plan. Approve it, and watch it land in your workspace.
  • Claude Code
  • Cursor
  • Codex
  • Windsurf
  • Grok
  • any MCP host
install
# Claude Code: records approved plans, resumes each session
/plugin marketplace add beckhq/beck-plugin
/plugin install beck@beck

# Any MCP host
npx @becklabs/beck-mcp-server
# BECK_API_TOKEN=beck_…  BECK_API_URL=https://beck.bot

Agents read the rules at /skill.md and /llms.txt. The REST API takes the same token. Step by step: Connect an agent.

All 41 tools what your agent can do in Beck

Pick up where you left off

  • resume
  • whoami
  • bind_workspace
  • list_workspaces
  • create_workspace

Plans and tasks

  • record_plan
  • create_epic
  • create_tasks
  • list_epics
  • get_epic
  • list_tasks
  • get_task
  • get_task_context
  • recommend_task
  • update_task
  • set_relevant_files

Working a task

  • start_task
  • log_progress
  • list_progress
  • finish_task
  • accept_task
  • reject_task
  • add_comment
  • list_comments

Decisions

  • ask_decision
  • answer_decision
  • list_decisions

Documents

  • list_documents
  • read_document
  • create_document
  • write_document
  • delete_document
  • list_document_versions
  • restore_document
  • plan_it
  • import_suggested_tasks

GitHub

  • link_epic_github
  • get_epic_github

Bot tokens

  • create_api_token
  • list_api_tokens
  • revoke_api_token

Not coding?

You don’t need a terminal to work with one.

  • Read the plan.

    Every recorded plan is a document in Beck: the why, the tasks, and what changed since.

  • Write the brief.

    Put specs and research in Documents. The agent reads them before it plans.

  • Answer from your phone.

    Waiting on you fits a small screen. Keep the default, or answer in a sentence.

  • Plan it.

    Without an agent, Beck's own AI turns a document into stories you can edit. It uses AI credits.

More on Documents

Give your agent somewhere to write things down.

See plans

Free includes 50 AI credits. Recorded plans, runs and decisions use none.