The most cost-effective setup is usually:

1) Use a cheap “planner” model, not a top-tier model for every step

A lot of agent cost comes from using an expensive model for:

• planning
• tool selection
• summarizing
• memory writes
• routing

Best practice:

• Use a smaller/cheaper model for routine agent control
• Escalate to a stronger model only for hard reasoning or final synthesis

This often cuts cost dramatically without hurting quality much.

---

2) Keep agents short-lived and task-scoped

Persistent always-on agents are expensive because they:

• accumulate context
• make unnecessary calls
• keep memory and sandbox state alive longer than needed

More cost-effective pattern:

• create an agent per research task
• give it a bounded objective
• terminate it when the answer is done

If you need continuity, store only the useful artifacts, not the whole conversation.

---

3) Minimize context size aggressively

Context window usage is one of the biggest hidden costs.

Do:

• summarize intermediate findings
• store only structured notes in memory
• retrieve only relevant snippets
• avoid replaying full chat histories

Don’t:

• keep long raw transcripts in the prompt
• feed all prior tool outputs back into every turn
• overuse reflection steps

A good rule: compress early, compress often.

---

4) Use memory for retrieval, not conversation replay

A memory system is cost-effective when it stores:

• facts
• sources
• decisions
• embeddings / retrieval indexes
• task outcomes

It becomes expensive when it’s used to reconstruct endless context.

Best pattern:

• write concise memory entries after each meaningful milestone
• retrieve only top-k relevant entries
• keep memory updates deterministic and small

---

5) Sandbox only what actually needs isolation

Sandboxing adds overhead, but it’s worth it when agents:

• run code
• browse untrusted pages
• process files
• interact with external systems

Cost-effective approach:

• use a shared sandbox pool or reusable containers if safe
• keep the environment minimal
• install dependencies once in a cached image
• avoid spinning up a fresh heavy VM for every tiny action

If your platform supports it, ephemeral containers with cached base images are usually cheaper than full VM isolation.

---

6) Batch and parallelize judiciously

Research agents often waste time by doing serial calls that could be batched:

• multiple web queries
• document extraction
• citation checks
• sub-question analysis

Batch where possible, but don’t parallelize blindly:

• too many parallel workers can increase tool and model calls
• coordination overhead can erase savings

Use parallelism for independent subtasks only.

---

7) Put hard limits on agent loops

Unbounded reflection/retry loops are a cost trap.

Set:

• max tool calls
• max reasoning steps
• max tokens per task
• timeout per sandbox session
• retry budget

Then use a fallback:

• return partial answer
• escalate to a stronger model
• ask for clarification

---

8) Make the agent extract structured outputs

Instead of long free-form notes, have the agent produce:

• bullets
• tables
• JSON
• citations
• short evidence summaries

Structured outputs are cheaper to store, cheaper to retrieve, and easier for later agents to consume.

---

9) Separate “search,” “read,” and “synthesize” roles

A very cost-effective architecture is:

• Searcher agent: cheap model, quick queries, broad discovery
• Reader agent: cheap/medium model, extracts relevant facts
• Synthesizer agent: stronger model only at the end

This avoids paying premium-model prices for every web lookup or document skim.

---

10) Cache everything reusable

Good caching often gives the biggest savings:

• search results
• fetched pages
• document parses
• embeddings
• summaries
• sandbox dependencies
• final answer drafts for repeated queries

If the same source is likely to be used again, store the cleaned version once.

---

Practical “most cost-effective” architecture

If I had to recommend one default setup:

• Cheap model for orchestration and most research steps
• Memory store with compact structured summaries and retrieval
• Ephemeral sandbox container only when code/file processing is needed
• Cached tools and fetched documents
• One strong model call only for final synthesis or difficult reasoning
• Strict step/token limits

That tends to be the best balance of quality and cost.

---

A simple rule of thumb

If you want to optimize for cost:

1. Reduce model size before reducing agent capability
2. Reduce context before increasing prompt complexity
3. Use sandboxes only for unsafe or stateful tasks
4. Use memory to retrieve, not to remember everything
5. Cache aggressively

If you want, I can also give you:

• a reference architecture
• a cost-optimized agent workflow
• or a comparison of common platforms for memory + sandboxing