Agent · Available now

Suggestion Agent

Sees the next optimal action before you do, from a five-minute fix to a year-long bet, in any field, and hands it to you ready to start. One focused workflow, with a clear result at the end.

Read docs

How it works

The Suggestion Agent looks at where you are and tells you what to do next, before you have worked it out yourself. You give it one goal in any field, whether that is a codebase, a thesis, a launch, a job search, or a shop, along with whatever you know: what is done, what is in progress, what you decided, what you must not touch, and what worries you. It drafts a wide pool of candidate next actions across 31 kinds of opportunity, from the quick win you walked past and the thing you should stop doing to the bet that could reshape the whole plan. An independent critic reviews that pool against your goal, throws out the weak, the vague, and the redundant, and sends the rest back to be sharpened. That review-and-revise cycle repeats for as many rounds as you allow, and only then are the strongest ideas ranked.

What comes back is a short, ranked slate of next actions rather than a brainstorm. Every idea says why it matters now, what it should earn you, the first step to take, the steps after that, the decisions it forces, the assumptions it rests on, and how you will know it is finished. Each one is labeled with an effort estimate, a horizon of now, next, or later, and whether it is ready to start or first needs evidence, a decision, or an unblocked dependency, so a five-minute fix and a year-long direction can sit side by side. Ideas point back to the exact notes, files, and facts you supplied, and an idea that cites something you never gave it is dropped before you see it. Any single idea can be pulled out as a self-contained packet and handed to a person or another agent to carry out, and a project remembers which ideas you accepted and rejected, so the next slate starts from your judgment instead of from zero.

The Suggestion Agent thinks and recommends, and it stops there. It reads only what you hand it, which is your goal, your context, and the files you name, and it never edits a file, runs a command, or changes anything in your project. It does not start work you have not chosen, and a handoff packet grants nobody permission to act. When the evidence does not support more ideas, it returns fewer and says so instead of padding the list. When the goal is too ambiguous to act on, it stops and asks you one precise question instead of guessing.

  • harness
  • hosted
  • usage
  • next-action
  • proactive
  • evidence-grounded
  • independent-critic
  • ranked-ideas
  • idea-categories
  • handoff-packets
  • project-memory
  • feedback-loop
  • decision-support
  • quick-wins
  • big-bets
  • strategy
  • any-domain

Agent environment

Pricing

Usage-based

  • harness
  • hosted
  • usage

You start the Suggestion Agent from vidbyte-cli, and it needs no Codex install and no OpenAI login of your own. Every generator, critic, and revision step is one model call that the CLI sends through Vidbyte to the model provider, OpenAI, and Vidbyte runs that call for you. Each call carries your goal, the context you supplied, the files and attachments you named, and the memory of the project you chose, so share only what you are willing to send to OpenAI. Your Vidbyte balance pays for each call at that model's per-token rate plus 2%, so more rounds, extra compute, more context, or a larger model all use more of it. Both the generator and the critic use gpt-6-sol at high reasoning effort unless you pick another model or effort, and the model's reasoning counts as output tokens.

To get started, install vidbyte-cli and log in with a Vidbyte API key that carries the models:invoke permission; an admin or full-access key also works. Add balance before the first run, because Vidbyte holds enough for the longest reply a call could return before it sends the call. A key without that permission is refused before any model is called, and a run that runs out of balance partway stops and returns the latest reviewed ideas instead of losing them. The install prompt below checks these steps and gives you the first command to run.

Run it from your own agent

Copy prompt

Paste this into the agent you already use and it will ask you what you need, then write the exact Suggestion Agent invocation for your job.

You are helping me use Vidbyte's Suggestion Agent, which sees the next optimal action on a goal in any field before I do and returns a short, reviewed, ranked slate. Ask me these one at a time and wait for each answer: (1) the one goal I wa…

Run it from the command line

Install vidbyte-cli and log in with a Vidbyte key that carries the models:invoke permission. Then run the agent with one goal and whatever context you have, and use the smaller commands to browse categories, hand ideas off, and keep project memory.

  1. bash
    pipx install vidbyte-cli

    Installs vidbyte-cli from PyPI, the command line every Vidbyte agent is started and tracked from. pipx gives it its own environment and puts the `vidbyte-cli` command on your PATH; without pipx, run `python -m pip install vidbyte-cli` inside an activated virtual environment instead, and read the CLI repository README for the full installation notes. Run `vidbyte-cli --version` afterwards, and if it prints a version number the install worked.

    View subcommands
    --python
    Picks the Python interpreter pipx builds the CLI's environment with, such as `--python python3.12`. vidbyte-cli needs Python 3.11 or newer, so set it when your default Python is older and the install refuses to resolve.
  2. bash
    vidbyte-cli login

    Stores your Vidbyte API key, which is what identifies you and what every agent's charge is billed against. It reads the key at a hidden prompt, checks it against Vidbyte before saving anything, and then keeps it in your operating system's keyring. Run `vidbyte-cli whoami` afterwards to confirm which account the stored key belongs to.

    View subcommands
    --with-token
    Reads the key from standard input instead of a hidden prompt, which is how you log in from a script or a CI job. Pipe it in from your secret store rather than typing it into the command. There is deliberately no --api-key flag, because anything in the command line leaks into process listings, shell history, and CI logs.
    --allow-file-fallback
    Approves storing the key in a permission-restricted file when the machine has no operating-system keyring, such as a bare Linux server. Without it, login asks before falling back, or refuses when there is no terminal to ask on. Anything running as your user can read that file, so use it only where a keyring genuinely is not available.
  3. bash
    vidbyte-cli agents suggest run --goal "<goal>"

    Generates, critiques, and ranks next actions for one goal, and prints the slate. The goal is the only required input; every other option adds context, narrows the search, or sets a limit. All of it is checked before any model is called, so a mistake fails for free. Each generator, critic, and revision step after that is one model call through Vidbyte, metered against your balance.

    View subcommands
    --goal
    States the one outcome you want the next actions to move toward, in up to 4,096 characters. It is required for every run. A specific goal, such as a date or a measurable result, produces far more specific ideas than a broad one.
    --project
    Loads the stored memory of one project, created earlier with project create, as context for this run. That memory is the project's title, its scope, and every suggestion you accepted or rejected with the reasons, and it travels through Vidbyte to the model with the rest of the request. Leave it out and the run reads no project file at all.
    --context
    Adds a background fact that does not fit a more specific option. Repeat it once per fact. Each value is carried to the agents as task data, never as an instruction.
    --files
    Adds a text, Markdown, or JSON file whose contents inform the run, repeated once per file. Only the paths you name are read; nothing else on disk is scanned. Oversized files are truncated and reported in the manifest rather than dropped silently. What is read is sent through Vidbyte to the model, so name only files you are willing to share.
    --attach
    Attaches one local file directly to the model's input, repeated once per file in order. Text files are sent as snapshots and supported images stay native images, both through Vidbyte to the model provider. Missing, duplicate, empty, unsupported, or oversized files fail before any model is called, and so does a call whose request would pass 2,000,000 bytes.
    --completed
    Records an outcome that is already true, so the agent does not propose it again. Repeat it once per finished item. This is the single most effective way to stop a slate from repeating work you already did.
    --in-progress
    Records work that has started but is not finished. The agent treats it as underway, so it can suggest how to finish or unblock it rather than proposing it as new. Repeat it once per item.
    --decision
    Records a decision already made, so ideas build on it instead of reopening it. Repeat it once per decision. Use it for settled choices, such as a vendor, a deadline, or an architecture.
    --constraint
    Records a hard limit every idea must respect, such as a budget, a team size, or a freeze. Repeat it once per constraint. Every idea is expected to respect it, and the independent critic reviews each idea against it.
    --avoid
    Names a direction you do not want proposed at all. Repeat it once per direction. It is softer than a forbidden action: it steers the search away rather than declaring something off limits.
    --mistakes
    Records a mistake already made, so the agent can suggest how to recover and avoid proposing a repeat. Repeat it once per mistake. Use it for errors that shaped where the work is now.
    --forbidden
    Declares an action that must never appear in a suggestion, such as deleting data or contacting customers. Repeat it once per action. Use it for anything that would be unacceptable, not merely unwanted.
    --approaches
    Records an approach you already tried or are considering, so the agent can compare against it or build on it. Repeat it once per approach. It keeps the slate from rediscovering what you already know.
    --outcomes
    Records a result you have already observed, such as a metric after a change. Repeat it once per outcome. Real outcomes let the agent judge what is working instead of guessing.
    --blockers
    Names something currently stopping progress. Repeat it once per blocker. Naming it points the agent at ideas that remove it.
    --hypotheses
    Records a belief you have not yet tested. Repeat it once per hypothesis. The agent can propose the cheapest way to confirm or kill each one.
    --risks
    Names a risk you already see. Repeat it once per risk. The agent can propose ways to reduce it, and spends less of the slate re-discovering it.
    --trajectory
    Describes the direction the work has been moving over time, such as a trend or the last few milestones. Repeat it once per note. It helps the agent tell a next step apart from a course correction.
    --question
    States an open question you want the ideas to help answer. Repeat it once per question. The agent treats each one as something worth resolving, not just as background.
    --capability
    Names a skill, tool, person, access grant, or resource available to you. Repeat it once per capability. Ideas can then use what you have instead of assuming you have nothing.
    --success
    States what success looks like for the goal. Repeat it once per criterion. The critic uses it to judge whether an idea actually moves you toward the finish line.
    --count
    Sets the most ideas the final slate may hold, from 2 to 100, defaulting to 5. It is a ceiling, not a quota, so a weaker field returns fewer ideas with a shortfall note. A larger count asks the model for a bigger pool of candidates, which means longer replies and more output tokens.
    --category
    Limits the search to one kind of opportunity, such as quick_wins, big_bets, risk_prevention, or strategy, repeated once per category. There are 31 categories, and unknown names are rejected before any model is called. Leave it out to consider the whole registry.
    --all-categories
    Explicitly asks for every category to be considered. This matches the behavior when no category is given, but records the intent in the saved request. It does not force one idea from each category.
    --horizon
    Chooses when ideas should become useful: now, next, later, or any, which is the default. Now keeps every idea to something you can start today, while later favors directions that pay off over time. Each idea still records its own horizon in the result.
    --rounds
    Sets how many critique-and-revision cycles refine the pool, from 1 to 8, defaulting to 2. More rounds help difficult or ambitious goals, and every round adds a critic call and a revision call, each metered against your balance. The run ends early if a revision leaves no candidates.
    --max-messages
    Caps how many times a critic may stop its review early and message the generator directly about one urgent problem, from 0 to 8, defaulting to 2. Once the limit is spent, critics always return a full review. Zero turns the messages off.
    --provider
    Names the model provider that Vidbyte sends the generator and critic calls to. The only accepted value is openai, which is also the default. It makes the source of a run's reasoning explicit in scripts.
    --model
    Names the model that drafts and revises the ideas, which every extra-compute generator uses too. It defaults to gpt-6-sol, and Vidbyte meters each call at the chosen model's own per-token rate plus 2%. Vidbyte refuses a model it has no rate for before any tokens are used.
    --critic-model
    Names the model for the independent critic only, leaving the generator on its own model. It also defaults to gpt-6-sol, and an unpriced model is refused the same way. Use it when you want review from a stronger, cheaper, or different model than the one drafting ideas.
    --extra-compute
    Runs one separate generator call for each selected category, on the generator model, and combines their ideas before critique. It finds more genuinely distinct directions, but every category adds its own metered model call, so it multiplies a run's usage. With all 31 categories, that is 31 generator calls before the first critique.
    --max-output-tokens
    Caps each individual model reply, from 1 to 128,000 tokens, defaulting to 32,000. The cap is sent with every call, so it bounds what one reply can use, and Vidbyte holds enough balance for a reply of that length while the call runs. A reply cut off at the cap stops the run with the last fully reviewed ideas and a warning to raise it.
    --max-total-tokens
    Bounds the token usage of the whole run, from 1 to 20,000,000 tokens, which makes it the main spend control for a run. It is checked before every model call, so once the budget is reached no new call starts and the run returns the last fully reviewed ideas. The result names the stop reason so a partial slate never looks complete.
    --timeout-seconds
    Sets a deadline for the whole run, from 1 second to 86,400 seconds. No new work starts after it passes, and the last fully reviewed ideas are returned. A request already in flight may finish slightly later.
    --dry-run
    Validates the whole request and prints its settings, the models it would use, and its context manifest without calling a model. It needs no stored key, sends nothing to Vidbyte, and uses none of your balance. Use it to confirm what a large request will read before you run it.
  4. bash
    vidbyte-cli agents suggest categories

    Lists the 31 categories the agent searches across, with a one-line summary of each. Use it to pick the right values for the category option. It never calls a model and needs no login.

    View subcommands
    --view-all
    Prints the summary list of every category, which is also the default output. It cannot be combined with the single-category view.
    --view
    Prints the full definition of one category, including the guidance the generator follows for it. Use it to understand exactly what a category will and will not produce before you select it.
  5. bash
    vidbyte-cli agents suggest handoff --input <result.json> --idea <idea-id>

    Extracts one idea from a saved result as a self-contained packet with its evidence and a copyable execution prompt. Save the result first by running with the JSON output option and redirecting it to a file. It reads the file locally, never calls a model, and grants nobody permission to act.

    View subcommands
    --input
    Points at the saved JSON result of an earlier run. The file is validated before any idea is selected. A file that is not a valid suggestion result fails with a clear error.
    --idea
    Names the exact idea to extract by its identifier, such as idea-003. A title, a prefix, or a close match is never accepted in its place. Copy the identifier from the result you saved.
  6. bash
    vidbyte-cli agents suggest project create --key <key> --title "<title>" --description "<scope>"

    Creates a local project that remembers your reactions to suggestions about one body of work. Create it once, then pass its key to every run about that work. It is stored only on your machine and never calls a model.

    View subcommands
    --key
    Sets the project's stable key: 1 to 64 lowercase letters, numbers, hyphens, or underscores, starting with a letter or number. Every later run and feedback call uses this key.
    --title
    Gives the project a short human-readable name. The generator reads it so it knows what body of work your feedback belongs to.
    --description
    Describes the project's scope in a sentence or two. A clear scope stops feedback about one area from misleading suggestions about another.
  7. bash
    vidbyte-cli agents suggest project list

    Lists every local project with its key, title, and description. Use it to recover a key in a new session. It opens no feedback file and never calls a model.

  8. bash
    vidbyte-cli agents suggest feedback accept --project <key> --suggestion "<idea>"

    Records that you clearly wanted a suggestion, so later runs lean toward ideas like it. Use feedback reject with the same options to record a suggestion you clearly refused. Both append to the project's history, and neither calls a model.

    View subcommands
    --project
    Names the project the reaction belongs to by its key. The project must already exist; feedback never creates one.
    --suggestion
    Gives the text of the suggestion you are reacting to. A rejected suggestion that later reappears word for word is removed before ranking.
    --reason
    Explains why you accepted or rejected it. It is optional, but the reason tells the next run which quality mattered, not just which idea.

Use cases

Each example names the problem, the setup, the command to run, and the result you should expect.

Why use this agent

A general agent is reactive by design: it waits for you to ask, and it answers the question as you framed it. The next optimal action is usually outside that framing, which is exactly why you had not seen it yet, so asking a general agent tends to hand your own blind spot back to you as a tidy list. It also answers at the size of the question: ask something small and every answer is small, ask something big and every answer is vague. You end up seeing either the fix for this afternoon or the direction for the year, never both on one page where you can weigh them. The Suggestion Agent is built to see the step before you do, so it searches past your framing on purpose and returns the small move and the big bet side by side. That works the same whether the goal is a codebase, a chapter, a job search, or a shop.

The second difference is that a general agent grades its own ideas, which means nobody grades them at all. Its first plausible list goes straight to you, anchored to the last thing you said, with the same safe moves it gave last time and support it may have invented. Here every idea is challenged by a reviewer whose only job is to reject it, and an idea that leans on a fact you never supplied does not reach you. When too few ideas survive, you get fewer ideas and a note saying so, never padding. The result is a slate you can act on without re-checking it yourself.

The third is what you can do with the answer. A general agent's suggestion is a paragraph, and turning it into work means rewriting it as a task someone can pick up. Here the idea you choose is already a task, with a first step and a finish line, and one command turns it into a packet a teammate or another agent can carry out. A general agent also forgets you overnight, so the idea you refused on Monday returns on Friday. With a project, your accepted and rejected ideas become part of every later run, so the slate gets closer to your judgment instead of starting over.

  • Seeing the step too late

    You usually find the most valuable next step days after it would have helped. This agent searches for it while it can still change what you do today. It looks past the question as you framed it, which is where the step you missed tends to be.

  • Generic advice for everything

    A general assistant hands the same checklist to every project. This agent works from what you told it is done, in progress, decided, and off limits. Every idea it returns is tied to your situation and cites the context it came from.

  • Only small ideas surface

    Most suggestion lists stop at incremental improvements. This agent deliberately covers the full range, from quick wins to big bets and long-term directions. You choose the size that fits the moment instead of never seeing the large options.

  • Only big ideas surface

    Strategy tools love grand directions and forget the step you can take this afternoon. Set the horizon to now and every idea is something you can start today. Each one still comes with a concrete first action rather than a theme to think about.

  • Advice limited to code

    Most agent tools only know how to suggest code changes. This agent works on any goal you can describe: a thesis, a launch, a hiring plan, a pricing change, or a codebase. Its categories cover research, strategy, learning, business growth, and product experience as well as technical work.

  • Nobody checks the ideas

    When one agent writes and approves its own list, weak ideas go straight to you. Here an independent critic reviews every candidate and sends the weak ones back or throws them out. You read ideas that already survived a challenge.

  • Lists padded with filler

    Ask for ten ideas and most tools give you ten, however many good ones exist. This agent treats the count as a maximum and returns fewer when the evidence runs out. The result says when that happened, so a short list is a signal, not a failure.

  • Ideas you cannot start

    A suggestion that says what to think about still leaves you to work out what to do. Every idea here names its first action, its following steps, and how you will know it is done. You can start the moment you choose.

  • Retyping ideas as tasks

    Turning a paragraph of advice into an assignment for someone else is work in itself. One command extracts any idea as a self-contained packet with its evidence and an execution prompt. You hand it to a teammate or another agent as it is.

  • The same rejected idea

    Tools without memory keep proposing what you already refused. A project remembers every idea you accepted and rejected, and why. A new idea that contains the text of one you rejected is dropped, and your reasons steer the rest.

  • Your agent never looks ahead

    Coding agents finish the task you gave them and then stop, even when the change left obvious work behind. Your agent can call this one with JSON output at the end of every task. It then comes back to you with the next step instead of waiting in silence.

  • One theme crowds out others

    In a single long answer, the first strong idea tends to pull every other idea toward it. Extra compute gives each category its own separate agent before critique combines them. The directions you get back are genuinely different from each other.

  • Ideas built on truncated notes

    Large inputs can be cut without you noticing, and a run built on half your notes looks complete. The dry run shows exactly what will be read, truncated, or left out before any model is called. Every real run also reports that manifest, and it names the kinds of context you never supplied.

  • Advice resting on invented facts

    A general agent will happily justify an idea with a detail you never gave it. Here an idea may only cite the notes, files, and facts you supplied, and one that cites anything else is dropped before ranking. What reaches you is traceable to your own material.

  • Confident guesses at vague goals

    Give a general agent an ambiguous goal and it guesses what you meant, then builds a whole list on the guess. When this agent cannot produce a worthwhile slate without something only you know, it stops and asks you one precise question. You answer once and rerun, instead of reading a list aimed at the wrong target.

When to use it

  • When you finished a piece of work and cannot see the highest-value next step.

  • When you suspect the step that matters is one nobody has mentioned yet.

  • When you want the one thing to do this afternoon, not a list of themes.

  • When a plan for the next quarter or year needs its bold options on the table.

  • When the goal is outside software: research, writing, a launch, hiring, or pricing.

  • When you are about to ship and want the unnamed risk found tonight.

  • When a decision has several genuinely different options and you have only heard two.

  • When you want every idea challenged before it reaches you.

  • When a short list you can trust beats a long list you have to filter.

  • When your coding agent should look ahead before it declares a task done.

  • When the chosen idea has to be handed to a teammate or another agent to carry out.

  • When you ask for suggestions on the same project week after week.

  • When a rejected idea keeps coming back and you are tired of explaining why.

  • When you have a pile of notes and want ideas grounded in them, not in general advice.

  • When you are new to a field and do not yet know what the good next moves look like.

  • When a meeting keeps circling and needs concrete options to react to.

  • When the next step must respect constraints, such as a freeze or a fixed team size.

  • When the most valuable move might be something to stop doing, not something to start.

  • When what you have been doing is producing numbers, and the numbers say it is not working.

  • When you are about to start something new and the very first move is unclear.

  • When the answer has to be traceable to your own notes because someone will ask where it came from.

Similar agents

More in agent workflows

  • Persistent Agent

    Pick this one next, once you have chosen an idea and need it pushed all the way to done.

    Open agent page →
  • Ensemble Agent

    Pick this one instead when the task is already decided and the open question is how to implement it.

    Open agent page →
  • Task Board

    Pick this one instead when you already have a plan you trust and need it executed step by step.

    Open agent page →
  • Persistent Researcher

    Pick this one instead when what you need is evidence gathered from the web, not a recommendation for what to do.

    Open agent page →