repo stringclasses 1
value | github_id int64 4.08B 4.1B | github_node_id stringclasses 3
values | number int64 721 726 | html_url stringclasses 3
values | api_url stringclasses 3
values | title stringclasses 3
values | body stringclasses 3
values | state stringclasses 2
values | state_reason stringclasses 1
value | locked bool 1
class | comments_count int64 1 1 | labels listlengths 0 0 | assignees listlengths 0 0 | created_at stringdate 2026-03-15 22:07:38 2026-03-19 08:29:00 | updated_at stringdate 2026-03-18 19:39:00 2026-03-21 23:30:14 | closed_at stringclasses 1
value | author_association stringclasses 2
values | milestone_title stringclasses 0
values | snapshot_id stringclasses 1
value | extracted_at stringdate 2026-03-24 21:31:19 2026-03-24 21:31:19 | author_login stringclasses 3
values | author_id int64 4.05M 261M | author_node_id stringclasses 3
values | author_type stringclasses 1
value | author_site_admin bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
evalstate/fast-agent | 4,096,044,862 | I_kwDONsNzVc70JK8- | 725 | https://github.com/evalstate/fast-agent/issues/725 | https://api.github.com/repos/evalstate/fast-agent/issues/725 | Get conversation history in non-interactive mode | Hi,
Is there a way to get the conversation history in the non-interactive mode? In the interactive mode, I can use `/history show`. I'd like something similar.
Something like this:
```python
fast = FastAgent(
"Agent",
parse_cli_args=True
)
@fast.agent("helpful assistant")
async def main(query):
async with fast.run() as agent_app:
result = await agent_app.send("do something")
history = agent_app.get_history()
return result, history
``` | open | null | false | 1 | [] | [] | 2026-03-18T15:42:44Z | 2026-03-18T19:39:00Z | null | NONE | null | 20260324T213119Z | 2026-03-24T21:31:19Z | ktrapeznikov | 4,052,002 | MDQ6VXNlcjQwNTIwMDI= | User | false |
evalstate/fast-agent | 4,100,128,608 | I_kwDONsNzVc70Yv9g | 726 | https://github.com/evalstate/fast-agent/issues/726 | https://api.github.com/repos/evalstate/fast-agent/issues/726 | Per-agent skills filtering is overridden by global static context in `enrich_with_environment_context` | Hi, thanks for the great work on fast-agent — the skills system is really well designed.
I ran into an issue when using per-agent `skills=` configurations in a multi-agent setup. All agents end up receiving the full set of skills regardless of their individual config.
## Description
When running multiple agents with different `skills=` configurations, all agents receive the full set of skills from the skills directory instead of only the skills they are configured with.
The root cause is that `enrich_with_environment_context()` in `prompt_templates.py` loads **all** skills and sets `context["agentSkills"]` as a static string. Later, in `InstructionBuilder.build()`, static context values are resolved (step 6) before dynamic resolvers (step 7). This means the per-agent dynamic resolver set up in `build_instruction()` (`instruction_refresh.py`) — which correctly uses filtered `skill_manifests` — never fires because `{{agentSkills}}` is already resolved by the global static value.
## Steps to Reproduce
1. Create two skills in `.fast-agent/skills/`:
- `skill-a/SKILL.md`
- `skill-b/SKILL.md`
2. Define two agents with different skill configurations:
```python
@fast.agent(
name="AgentA",
instruction="You handle task A. {{agentSkills}}",
skills=["./skills-a"] # directory containing only skill-a
)
@fast.agent(
name="AgentB",
instruction="You handle task B. {{agentSkills}}",
skills=["./skills-b"] # directory containing only skill-b
)
```
3. Run the application with both agents.
4. Inspect the resolved system prompt for each agent — both will contain **all** skills from **all** directories, not just the ones from their configured `skills=` path.
## Root Cause
In `src/fast_agent/core/prompt_templates.py`, lines 186-193:
```python
# enrich_with_environment_context()
if cwd:
skill_manifests = load_skills_for_context(cwd, skills_directory_override)
skills_text = format_skills_for_prompt(skill_manifests, read_tool_name="read_text_file")
context["agentSkills"] = skills_text # <-- sets ALL skills as static context
```
This `context` dict is passed as `global_prompt_context` to `_apply_instruction_context` in `fastagent.py`. When `InstructionBuilder.build()` runs, it resolves `{{agentSkills}}` from static context values **before** reaching the dynamic resolver that would use the agent's filtered `skill_manifests`.
Resolution order in `InstructionBuilder.build()`:
- Step 6: Static context values -> `{{agentSkills}}` gets replaced with ALL skills
- Step 7: Dynamic resolvers -> `agentSkills` resolver is skipped (placeholder already resolved)
Meanwhile, the per-agent resolver is correctly set up in `instruction_refresh.py`:
```python
builder.set_resolver("agentSkills", resolve_agent_skills) # uses filtered manifests
```
But it never gets a chance to run.
## Suggested Fix
Remove `context["agentSkills"]` from `enrich_with_environment_context()`. Each agent already resolves `{{agentSkills}}` via its own dynamic resolver in `build_instruction()` (which uses `agent.skill_manifests`). The global context should not set this key.
```diff
- if cwd:
- from fast_agent.skills.registry import format_skills_for_prompt
- skill_manifests = load_skills_for_context(cwd, skills_directory_override)
- skills_text = format_skills_for_prompt(skill_manifests, read_tool_name="read_text_file")
- context["agentSkills"] = skills_text
+ # agentSkills is resolved per-agent by the dynamic resolver in
+ # build_instruction (via agent.skill_manifests). Setting it here
+ # as a static value would override per-agent filtering because
+ # static context resolves before dynamic resolvers in
+ # InstructionBuilder.build().
```
## Notes
- In single-agent setups (the typical `fast-agent go` use case), this bug is invisible because the one agent receives all skills anyway.
- The bug only manifests when running multiple agents with different `skills=` configurations — each agent ends up with the full skill set regardless of its config.
- The `mcp_agent.py` initialization correctly filters manifests based on `skills=` config (`SKILLS_DEFAULT` check, `skill_manifests` from `AgentConfig`), so the filtering logic itself is sound. It's only the global static context that short-circuits it.
Happy to submit a PR if that would be helpful. | closed | completed | false | 1 | [] | [] | 2026-03-19T08:29:00Z | 2026-03-20T08:16:16Z | 2026-03-20T08:16:16Z | CONTRIBUTOR | null | 20260324T213119Z | 2026-03-24T21:31:19Z | phucly95 | 30,800,395 | MDQ6VXNlcjMwODAwMzk1 | User | false |
evalstate/fast-agent | 4,079,299,100 | I_kwDONsNzVc7zJSoc | 721 | https://github.com/evalstate/fast-agent/issues/721 | https://api.github.com/repos/evalstate/fast-agent/issues/721 | GNAP: git-native coordination for fast-agent multi-model pipelines | Hi fast-agent team 👋
fast-agent's composition model (chains, parallel agents, routers, evaluator-optimizers) is one of the cleanest approaches to multi-agent orchestration I've seen. I wanted to raise a question about cross-process and multi-machine coordination.
**The gap:** fast-agent's workflow composition is elegant but in-process. If you're running a `parallel` of 5 agents and want to distribute them across machines, or resume after a failure, there's no built-in mechanism.
**[GNAP](https://github.com/farol-team/gnap)** is an open RFC for zero-server agent coordination. The protocol: agents read `tasks/*.json`, do work, write results, commit and push. Git is the only infrastructure needed.
**fast-agent integration idea:**
fast-agent's `@fast.chain()` and `@fast.parallel()` decorators could optionally back their task queues with GNAP:
```python
@fast.chain(
name="research_pipeline",
backend="gnap", # durability via git
gnap_repo="./agent-workspace"
)
async def research_chain():
...
```
This would make fast-agent workflows:
- **Resumable** — crashed mid-chain? Pull and continue
- **Distributable** — run chain steps on different machines
- **Auditable** — full git history of every agent step
- **Interoperable** — any MCP-compatible agent can participate via GNAP
Given fast-agent's focus on building with open-source models, the zero-infrastructure aspect of GNAP seems especially aligned.
Happy to discuss or prototype a `GNAPBackend` for fast-agent.
Protocol spec: https://github.com/farol-team/gnap | open | null | false | 1 | [] | [] | 2026-03-15T22:07:38Z | 2026-03-21T23:30:14Z | null | NONE | null | 20260324T213119Z | 2026-03-24T21:31:19Z | ori-cofounder | 261,421,922 | U_kgDOD5T7Yg | User | false |
Transformers PR Slop Dataset
Normalized snapshots of issues, pull requests, comments, reviews, and linkage data from evalstate/fast-agent.
Files:
issues.parquetpull_requests.parquetcomments.parquetissue_comments.parquet(derived view of issue discussion comments)pr_comments.parquet(derived view of pull request discussion comments)reviews.parquetpr_files.parquetpr_diffs.parquetreview_comments.parquetlinks.parquetevents.parquetnew_contributors.parquetnew-contributors-report.jsonnew-contributors-report.md
Use:
- duplicate PR and issue analysis
- triage and ranking experiments
- eval set creation
Notes:
- updated daily
- latest snapshot:
20260324T213119Z - raw data only; no labels or moderation decisions
- PR metadata, file-level patch hunks, and full unified diffs are included
- new contributor reviewer artifacts are included when generated for the snapshot
- full file contents for changed files are not included
- Downloads last month
- 6