Projector Tool¶

The Projector tool provides AI-native project management with persistent strategies. It tracks projects, tasks, and session outcomes while injecting working instructions into every session automatically. Think of it as project memory that follows you across conversations.

Operations¶

Operation	Purpose	Key Parameters
`list_projects`	List all tracked projects	Optional query filter
`get_project`	Get project details	Project name
`create_project`	Create a new project	Project name, data
`update_project`	Update project metadata	Project name, data
`list_strategies`	List strategies (global or project-scoped)	Optional project name
`get_strategy`	Get strategy details	Strategy name
`set_strategy`	Create or update a strategy	Strategy name, data
`toggle_strategy`	Enable or disable a strategy	Strategy name
`add_task`	Add a task to a project	Project name, task data
`update_task`	Update task status	Project name, task data
`list_tasks`	List tasks for a project	Project name, optional query
`log_outcome`	Log a session outcome	Project name, outcome data
`get_status`	Cross-project status query	Optional query

Basic Usage¶

Conversation Format¶

You interact with Projector through natural language. Amplifier translates your requests into the appropriate operations:

> What projects am I tracking?

[Tool: projector]
Operation: list_projects
Result: 3 projects found:
  - amplifier-core (active, 12 tasks, 3 pending)
  - tutorial-site (active, 8 tasks, 1 pending)
  - client-api (paused, 5 tasks, 0 pending)

Creating a Project¶

> Create a project called "auth-redesign" for rebuilding our
  authentication system

[Tool: projector]
Operation: create_project
Project: auth-redesign
Data: { description: "Rebuild authentication system" }

Adding Tasks¶

> Add a task to auth-redesign: migrate from session tokens to JWTs

[Tool: projector]
Operation: add_task
Project: auth-redesign
Data: { content: "Migrate from session tokens to JWTs" }

Checking Status¶

> What's the status across all my projects?

[Tool: projector]
Operation: get_status
Result: Summary across 3 projects:
  - auth-redesign: 2/5 tasks complete, blocked on database migration
  - tutorial-site: 7/8 tasks complete, one page remaining
  - client-api: paused, no recent activity

Strategies¶

Strategies are the most distinctive feature of Projector. They are persistent working instructions that automatically inject into every Amplifier session, shaping how the agent works without you repeating yourself.

What Strategies Do¶

When you set a strategy, it becomes part of the context for every future session in that project (or globally). The agent sees your strategies and follows them as standing instructions.

Example strategies: - "Always run tests before committing" - "Use TDD for all new features" - "Prefer composition over inheritance" - "Never add dependencies without checking bundle size impact" - "Always validate input at module boundaries"

Managing Strategies Conversationally¶

You don't need to memorize operations. Just talk naturally:

> Add a strategy: always run the full test suite before committing

[Tool: projector]
Operation: set_strategy
Data: {
  name: "pre-commit-tests",
  content: "Always run the full test suite before committing",
  scope: "global"
}

Strategy created and activated. This instruction will apply
to all future sessions.

Global vs Project-Scoped¶

Strategies can apply everywhere or only within a specific project:

> Add a global strategy: prefer simple solutions over clever ones

Global strategy -- applies to every project.

> Add a strategy for auth-redesign: all endpoints must require
  authentication by default

Project strategy -- only applies when working in auth-redesign.

Viewing and Toggling¶

> Show my active strategies

Active Strategies:
  Global:
    1. pre-commit-tests: "Always run the full test suite before committing"
    2. simplicity: "Prefer simple solutions over clever ones"

  auth-redesign:
    1. auth-default: "All endpoints must require authentication by default"

> Disable the pre-commit-tests strategy temporarily

[Tool: projector]
Operation: toggle_strategy
Strategy: pre-commit-tests
Result: Strategy disabled. It won't inject into sessions until re-enabled.

Toggling is useful when a strategy applies most of the time but gets in the way for specific tasks.

Logging Outcomes¶

After completing work in a session, Projector can log what was accomplished. This creates a persistent record of progress across sessions:

> Log outcome: completed JWT migration for the users endpoint,
  all tests passing

[Tool: projector]
Operation: log_outcome
Project: auth-redesign
Data: {
  summary: "Completed JWT migration for users endpoint",
  details: "All tests passing, 15 tests added"
}

Outcomes accumulate over time, giving you a history of what was accomplished and when. This is especially valuable when returning to a project after time away.

Companion Agents¶

Projector includes two specialized agents that provide higher-level analysis beyond basic CRUD operations.

project-analyst¶

The Project Analyst provides cross-project status analysis. It looks at task completion rates, identifies blocked work, spots patterns across projects, and recommends priorities.

> Analyze my project health and recommend what to focus on this week

project-analyst: Reviews all projects, identifies that auth-redesign
has a blocked task creating a cascade, recommends unblocking the
database migration first, then finishing the tutorial-site page.

Best for: Weekly planning, identifying bottlenecks, cross-project prioritization.

strategy-advisor¶

The Strategy Advisor helps you define, evaluate, and restructure your strategies. It identifies redundant strategies, suggests missing ones based on your work patterns, and helps refine vague strategies into actionable instructions.

> Review my strategies and suggest improvements

strategy-advisor: Notes that "prefer simple solutions" is too vague
for consistent application. Suggests replacing with: "When choosing
between approaches, pick the one with fewer moving parts. If two
approaches have similar complexity, pick the one that's easier to
delete later."

Best for: Strategy hygiene, onboarding new team patterns, refining working agreements.

Common Patterns¶

Project Setup Pattern¶

When starting a new project, establish the structure upfront:

1. Create the project with a clear description
2. Add initial tasks from your requirements
3. Set project-specific strategies
4. Log your initial planning as the first outcome

> Create a project called "api-v2" for our API version 2 migration.
  Add tasks: design new endpoint schema, write migration scripts,
  update client SDK, write integration tests, update documentation.
  Add a strategy: maintain backward compatibility with v1 for 6 months.

Daily Standup Pattern¶

Start each session by checking status:

> What's the status of api-v2? What did I last work on?

Projector shows current task states and recent outcomes,
giving you context to pick up where you left off.

Strategy Evolution Pattern¶

Strategies aren't permanent. Refine them as you learn:

> The "always run full test suite" strategy is too slow for
  small changes. Update it to: run affected tests for small
  changes, full suite before commits to main.

[Tool: projector]
Operation: set_strategy
Updates the existing strategy with refined instructions.

Try It Yourself¶

Set Up a Project¶

Create a project called "learning-amplifier" to track my progress
through this tutorial. Add tasks for each section I want to complete.

Define Working Strategies¶

Add these strategies for my learning-amplifier project:
- Take notes on each new concept
- Try every "Try It Yourself" exercise
- Build a small project using each tool I learn

Track Progress¶

Log outcome for learning-amplifier: completed the Tools Reference
section. Key takeaways: bash for builds, grep for search, prefer
specialized tools over bash when available.

Get Recommendations¶

Analyze my learning-amplifier project and suggest what to
focus on next.

Best Practices¶

Keep strategies actionable: "Write good code" is too vague. "Run pyright before committing to catch type errors" is actionable.
Review strategies periodically: Strategies that made sense last month may not apply now. Use the strategy-advisor to audit regularly.
Log outcomes consistently: The more outcomes you log, the better context you have when returning to a project. Even brief notes help.
Use project scope for specifics: Global strategies should be universally applicable. Project-specific patterns belong in project-scoped strategies.
Toggle instead of delete: If a strategy might be useful again, disable it rather than removing it. You can re-enable later.
Start with few strategies: Two or three well-defined strategies are better than ten vague ones. Add more as patterns emerge from your actual work.

Errors and Troubleshooting¶

Project Not Found¶

Error: Project "myproject" not found

Solution:
1. Check spelling: list_projects to see exact names
2. Names are case-sensitive
3. Create it if it doesn't exist yet

Strategy Not Applying¶

Problem: Strategy exists but agent doesn't seem to follow it

Solution:
1. Verify strategy is enabled: list_strategies
2. Check scope: global strategies apply everywhere,
   project strategies only in that project's directory
3. Rephrase strategy to be more specific and actionable

Stale Task Status¶

Problem: Task shows "pending" but work is done

Solution:
1. Update the task: update_task with new status
2. Log the outcome to record completion context

Advanced Patterns¶

Strategy Layering¶

Combine global and project strategies for nuanced behavior:

Global: "Prefer composition over inheritance"
Project: "Use the Strategy pattern for all payment processors"

The agent sees both and applies the project-specific strategy
as a concrete application of the global principle.

Cross-Project Analysis¶

Use get_status with queries to find patterns:

> Which projects have tasks blocked for more than a week?
> Show me all projects that haven't had activity this month
> What's my completion rate across all active projects?

Outcome-Driven Planning¶

Review past outcomes to inform future work:

> Show me all outcomes for api-v2 from last week.
  Based on that progress, what should this week's priorities be?

Next Steps: - Learn about Task (Sub-Agents) for delegating to specialized agents - Explore Recipes Tool for automated multi-step workflows - See Bash Tool for shell command execution