Home › Agents
AI agents on your native sessions
Your workflow.
Your supporting cast.
Bring reviewer, helper, and follower agents into the coding workflow you already use. Choose the models behind the roles. Give each a job worth doing.
Spontaneous Memory, below, runs on our own Claude Code sessions every day, and the tutorial shows how it works, limits included.
Your main agent doesn't have to do every job.
A second perspective. A focused pair of hands. Someone keeping an eye on the bigger picture. Different roles, working around the same task.
01 · REVIEWER
Another set of eyes.
Bring in an agent to examine changes, question assumptions, and surface issues before you move on.
Example brief: “Review this change for failure paths and explain what needs attention.”
02 · HELPER
A job of its own.
Give a helper a bounded task alongside the main work: investigate a question, check an assumption, or prepare a focused result.
Example brief: “Check the relevant documentation and report the constraints.”
03 · FOLLOWER
The wider view.
Have a follower track work as it develops and contribute observations without taking over the main task.
Example brief: “Watch for decisions that conflict with the project's earlier direction.”
Your logic, at the agent's hooks.
At the heart is an open-source framework: a place to connect your own code to supported events in the AI workflow.
Define the job. Choose the model.
Use different models for different roles across supported providers. A reviewer needn't use the same model as the agent doing the work.
Give each role instructions, relevant context, and a clear scope. The framework is the foundation; the frontend is where those roles and their work become visible.
When this happens…
A supported event makes relevant work available.
…run your logic…
A check, a reviewer, or another focused contribution.
…within its authority.
Advice, observation, and permission to act are different things.
Provider choice depends on available integrations and credentials. Triggers, context access, execution and delivery vary by role and runtime.
The framework and your configuration
The machinery is shared. The workflow is yours.
Crossing Guard provides the mechanisms. Your configuration describes how you want to use them. You don't have to adopt our development process to use the framework.
Framework
The connections to supported agent hooks, the machinery for running checks and evaluating rules, and the records of what happened. It defines the available capabilities and their boundaries.
Configuration
Your chosen models, agent instructions, selected rules, and workflow criteria. What should a reviewer look for? Which facts matter to your project? Those choices belong to you, not hidden inside the framework.
Custom code
When existing mechanisms aren't enough, extend the framework at supported integration points. Add a check or integration, then configure how your workflow uses it.
Shared mechanism: run a reviewer and record its findings.
Your configuration: choose its model and instructions—review database changes for one project, accessibility for another.
An extension when needed: connect a project-specific checker through a supported integration point.
The frontend makes those choices visible.
The interface brings configuration and results together: what is selected, which agent contributed, and what it reported. Available controls depend on the role and integration.
A supplied configuration pack is a starting point, not a mandatory workflow. Configuration cannot create a missing hook, enable unsupported live interruption, or grant an agent authority by itself. Spontaneous Memory's delivery stays within those same boundaries.
Spontaneous Memory · in daily use on our own Claude Code sessions
The “aha” you didn't know to ask for.
Your main agent follows the task. A memory follower looks beyond that immediate context for a past decision, forgotten constraint, or relevant lesson that could change the work.
It goes beyond what you asked it to remember. It connects the task to knowledge outside the main line of context, and brings it back when it matters.
“Before you continue: we tried this approach before. Here's why we changed it.”
Example message.
At the next prompt or tool call
The note arrives with the session's next prompt or tool call, at a moment when the working agent can use it.
Only when it matters
Most turns end without a note. The follower speaks up when a past decision adds something the session hasn't already acknowledged.
Will a memory interrupt my agent?
No. A note waits for the session's next prompt or tool call and arrives as added context, so the agent is never stopped partway through a step. Live interruption is a different capability and isn't part of Spontaneous Memory. Today notes reach Claude Code sessions. Delivery to Codex and OpenCode is built but we haven't seen it work yet.
Where does the helper's model run?
On our install the helper uses a hosted model, so the conversation excerpts and memory records it reads are sent to that provider. It can be pointed at a local model instead, which we haven't tested end to end yet.
Does an “aha” give the follower permission to act?
No. A relevant memory is context, not an instruction with higher authority. The follower's contribution remains separate from permission to approve, change files, or control another agent.
Same workflow. More perspective.
Shared memory, shared rules, and your own supporting agents. The crossing guard stays at the intersection; you decide who joins the work.
Back to Crossing Guard →