Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Research Grant Writing · FreedomIntelligence | DecimalAI

Researchby FreedomIntelligence

Research Grant Writing

Write competitive research proposals for NSF, NIH, DOE, and DARPA. Agency-specific formatting, review criteria, budget preparation, broader impacts, significance statements, innovation narratives, and compliance with submission requirements.

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

100%0%of checks passed -100 pts

Without skill100%

With skill0%

1 fixed1 passed either way20 still failing0 broke

Measured on gemini-3.6-flash7/26/2026v121 comparable

Track record

Agent runs: 0; All time

Use this skill

Your agent runs on

Adds every file the skill has, pinned so you can update it. No account needed.

pip install "decimalai>=0.15"
decimalai skills add research-grants
claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

The same install from Python, for a notebook or a setup script.

Install

pip install "decimalai>=0.15"

Add the skill

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

print("Added. Start Claude Code with the command below.")

Start Claude Code with it

claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

Type these in a Claude Code session. No account or API key. It writes the skill and any files it bundles, and asks first when its safety rating isn't Passed.

Add the DecimalAI plugin, once

/plugin marketplace add decimal-labs/decimalai-claude-plugins
/plugin install decimalai@decimalai

Install this skill

/decimalai:install research-grants

The plugin needs python3 and curl on your machine.

No Python or account. Claude Code picks it up in its next session.

Save it into your project

curl -fsSL --create-dirs -o .claude/skills/research-grants/SKILL.md https://app.decimal.ai/s/research-grants/SKILL.md

Copy SKILL.md

Save it in your project, as

.claude/skills/research-grants/SKILL.md

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Claude Code docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"
decimalai skills add research-grants

Add it to your agent

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from claude_agent_sdk import ClaudeAgentOptions, query

skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
options = ClaudeAgentOptions(system_prompt=f"You are a helpful agent.\n\n{skill}", max_turns=6)

async def main():
    async for message in query(prompt="Hello!", options=options):
        print(message)

# In a notebook or async code: await main()
asyncio.run(main())

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Claude Agent SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai-agents]"
decimalai skills add research-grants

Add it to your agent

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

Install

pip install "decimalai[openai-agents]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
agent = Agent(name="support", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

OpenAI Agents docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai]"
decimalai skills add research-grants

Add it to your agent

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

Install

pip install "decimalai[openai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

client = OpenAI()
skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
reply = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[
        {"role": "system", "content": f"You are a helpful agent.\n\n{skill}"},
        {"role": "user", "content": "Hello!"},
    ],
).choices[0].message

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

OpenAI SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[anthropic]"
decimalai skills add research-grants

Add it to your agent

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

Install

pip install "decimalai[anthropic]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

client = anthropic.Anthropic()
skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
reply = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,
    system=f"You are a helpful agent.\n\n{skill}",
    messages=[{"role": "user", "content": "Hello!"}],
)

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Anthropic docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[google-genai]"
decimalai skills add research-grants

Add it to your agent

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

Install

pip install "decimalai[google-genai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Hello!",
    config=types.GenerateContentConfig(system_instruction=f"You are a helpful agent.\n\n{skill}"),
)

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Gemini API docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[langchain]" langchain-openai
decimalai skills add research-grants

Add it to your agent

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

Install

pip install "decimalai[langchain]" langchain-openai

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
agent = create_agent("openai:gpt-5.4-mini", tools=[], system_prompt=f"You are a helpful agent.\n\n{skill}")
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

LangChain docs

CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"
decimalai skills add research-grants

Add it to your agent

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

The same install from Python, for a notebook or a setup script. CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

No DecimalAI package. CrewAI's own loader reads the folder, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                         # your own CrewAI LLM
    skills=[Path(".agents/skills")],
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

CrewAI docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[adk]"
decimalai skills add research-grants

Add it to your agent

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

Install

pip install "decimalai[adk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from google.adk.agents import LlmAgent

skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
agent = LlmAgent(
    name="support",
    model="gemini-3.5-flash",
    instruction=lambda context: f"You are a helpful agent.\n\n{skill}",
)

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Google ADK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[pydantic-ai]"
decimalai skills add research-grants

Add it to your agent

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

Install

pip install "decimalai[pydantic-ai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
agent = Agent("openai:gpt-4o-mini", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Pydantic AI docs

Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents
decimalai skills add research-grants

Add it to your agent

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

The same install from Python, for a notebook or a setup script. Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
agent = create_deep_agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Deep Agents docs

Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework
decimalai skills add research-grants

Add it to your agent

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

The same install from Python, for a notebook or a setup script. Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
agent = Agent(client=client, instructions=f"You are a helpful agent.\n\n{skill}")
asyncio.run(agent.run("Hello!"))

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Microsoft Agent Framework docs

Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents
decimalai skills add research-grants

Add it to your agent

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

The same install from Python, for a notebook or a setup script. Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("research-grants")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/research-grants/SKILL.md").read_text()
agent = Agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent("Hello!")

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Strands docs

Adds every file the skill has, pinned so you can update it. Cursor, Copilot, Cline and Warp read this folder by themselves.

pip install "decimalai>=0.15"
decimalai skills add research-grants

No Python or account. Cursor, Copilot, Cline and Warp read this folder by themselves.

Save it into your project

curl -fsSL --create-dirs -o .agents/skills/research-grants/SKILL.md https://app.decimal.ai/s/research-grants/SKILL.md

Copy SKILL.md

Save it in your project, as

.agents/skills/research-grants/SKILL.md

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Cursor and other editors docs

Fetch the file and give its text to your model as instructions. No account or package needed.

Get the file

curl -fsSL https://app.decimal.ai/s/research-grants/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/research-grants.json

This gets SKILL.md only. The skill's 9 other files are not included.

Other ways to add it

Other setups docs

You don't need a DecimalAI account.

Version: v1, tested 7/26/2026
Source: FreedomIntelligence/OpenClaw-Medical-Skills ↗
License: Not recorded

Manage it in DecimalAI

Saved prompts and skills, pinned versions, and traces of this skill in your runs. DecimalAI does not run your agent.

Claude Code reads files from your project, so DecimalAI config does not apply there.

On Claude Agent SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI Agents: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Anthropic: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Gemini API: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On LangChain: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On CrewAI: set DECIMAL_API_KEY and add decimalai.init(crewai=True) to record runs and skill use. The skill version stays in your repo.

On Google ADK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Pydantic AI: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Deep Agents: set DECIMAL_API_KEY and add decimalai.init(langchain=True) to record runs and skill use. The skill version stays in your repo.

On Microsoft Agent Framework: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

On Strands: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

Editors read files from your project, so DecimalAI config does not apply there.

Anywhere else: record a use with decimalai.log_skill_activation() inside a trace.

Use this skill

SKILL.md

Research Grant Writing

Overview

Research grant writing is the process of developing competitive funding proposals for federal agencies and foundations. Master agency-specific requirements, review criteria, narrative structure, budget preparation, and compliance for NSF (National Science Foundation), NIH (National Institutes of Health), DOE (Department of Energy), and DARPA (Defense Advanced Research Projects Agency) submissions.

Critical Principle: Grants are persuasive documents that must simultaneously demonstrate scientific rigor, innovation, feasibility, and broader impact. Each agency has distinct priorities, review criteria, formatting requirements, and strategic goals that must be addressed.

When to Use This Skill

This skill should be used when:

Writing research proposals for NSF, NIH, DOE, or DARPA programs
Preparing project descriptions, specific aims, or technical narratives
Developing broader impacts or significance statements
Creating research timelines and milestone plans
Preparing budget justifications and personnel allocation plans
Responding to program solicitations or funding announcements
Addressing reviewer comments in resubmissions
Planning multi-institutional collaborative proposals
Writing preliminary data or feasibility sections
Preparing biosketches, CVs, or facilities descriptions

Visual Enhancement with Scientific Schematics

⚠️ MANDATORY: Every research grant proposal MUST include at least 1-2 AI-generated figures using the scientific-schematics skill.

This is not optional. Grant proposals without visual elements are incomplete and less competitive. Before finalizing any document:

Generate at minimum ONE schematic or diagram (e.g., project timeline, methodology flowchart, or conceptual framework)
Prefer 2-3 figures for comprehensive proposals (research workflow, Gantt chart, preliminary data visualization)

How to generate figures:

Use the scientific-schematics skill to generate AI-powered publication-quality diagrams
Simply describe your desired diagram in natural language
Nano Banana Pro will automatically generate, review, and refine the schematic

How to generate schematics:

python scripts/generate_schematic.py "your diagram description" -o figures/output.png

The AI will automatically:

Create publication-quality images with proper formatting
Review and refine through multiple iterations
Ensure accessibility (colorblind-friendly, high contrast)
Save outputs in the figures/ directory

When to add schematics:

Research methodology and workflow diagrams
Project timeline Gantt charts
Conceptual framework illustrations
System architecture diagrams (for technical proposals)
Experimental design flowcharts
Broader impacts activity diagrams
Collaboration network diagrams
Any complex concept that benefits from visualization

For detailed guidance on creating schematics, refer to the scientific-schematics skill documentation.

Agency-Specific Overview

NSF (National Science Foundation)

Mission: Promote the progress of science and advance national health, prosperity, and welfare

Key Features:

Intellectual Merit + Broader Impacts (equally weighted)
15-page project description limit (most programs)
Emphasis on education, diversity, and societal benefit
Collaborative research encouraged
Open data and open science emphasis
Merit review process with panel + ad hoc reviewers

NIH (National Institutes of Health)

Mission: Enhance health, lengthen life, and reduce illness and disability

Key Features:

Specific Aims (1 page) + Research Strategy (12 pages for R01)
Significance, Innovation, Approach as core review criteria
Preliminary data typically required for R01s
Emphasis on rigor, reproducibility, and clinical relevance
Modular budgets ($250K increments) for most R01s
Multiple resubmission opportunities

DOE (Department of Energy)

Mission: Ensure America's security and prosperity through energy, environmental, and nuclear challenges

Key Features:

Focus on energy, climate, computational science, basic energy sciences
Often requires cost sharing or industry partnerships
Emphasis on national laboratory collaboration
Strong computational and experimental integration
Energy innovation and commercialization pathways
Varies by office (ARPA-E, Office of Science, EERE, etc.)

DARPA (Defense Advanced Research Projects Agency)

Mission: Make pivotal investments in breakthrough technologies for national security

Key Features:

High-risk, high-reward transformative research
Focus on "DARPA-hard" problems (what if true, who cares)
Emphasis on prototypes, demonstrations, and transition paths
Often requires multiple phases (feasibility, development, demonstration)
Strong project management and milestone tracking
Teaming and collaboration often required
Varies dramatically by program manager and BAA (Broad Agency Announcement)

Core Components of Research Proposals

1. Executive Summary / Project Summary / Abstract

Every proposal needs a concise overview that communicates the essential elements of the research to both technical reviewers and program officers.

Purpose: Provide a standalone summary that captures the research vision, significance, and approach

Length:

NSF: 1 page (Project Summary with separate Overview, Intellectual Merit, Broader Impacts)
NIH: 30 lines (Project Summary/Abstract)
DOE: Varies (typically 1 page)
DARPA: Varies (often 1-2 pages)

Essential Elements:

Clear statement of the problem or research question
Why this problem matters (significance, urgency, impact)
Novel approach or innovation
Expected outcomes and deliverables
Qualifications of the team
Broader impacts or translational pathway

Writing Strategy:

Open with a compelling hook that establishes importance
Use accessible language (avoid jargon in opening sentences)
State specific, measurable objectives
Convey enthusiasm and confidence
Ensure every sentence adds value (no filler)
End with transformative vision or impact statement

Common Mistakes to Avoid:

Being too technical or detailed (save for project description)
Failing to articulate "why now" or "why this team"
Vague objectives or outcomes
Neglecting broader impacts or significance
Generic statements that could apply to any proposal

2. Project Description / Research Strategy

The core technical narrative that presents the research plan in detail.

Structure Varies by Agency:

NSF Project Description (typically 15 pages):

Introduction and background
Research objectives and questions
Preliminary results (if applicable)
Research plan and methodology
Timeline and milestones
Broader impacts (integrated throughout or separate section)
Prior NSF support (if applicable)

NIH Research Strategy (12 pages for R01):

Significance (why the problem matters)
Innovation (what's novel and transformative)
Approach (detailed research plan)
- Preliminary data
- Research design and methods
- Expected outcomes
- Potential problems and alternative approaches

DOE Project Narrative (varies):

Background and significance
Technical approach and innovation
Qualifications and experience
Facilities and resources
Project management and timeline

DARPA Technical Volume (varies):

Technical challenge and innovation
Approach and methodology
Schedule and milestones
Deliverables and metrics
Team qualifications
Risk assessment and mitigation

For detailed agency-specific guidance, refer to:

references/nsf_guidelines.md
references/nih_guidelines.md
references/doe_guidelines.md
references/darpa_guidelines.md

3. Specific Aims (NIH) or Objectives (NSF/DOE/DARPA)

Clear, testable goals that structure the research plan.

NIH Specific Aims Page (1 page):

Opening paragraph: Gap in knowledge and significance
Long-term goal and immediate objectives
Central hypothesis or research question
2-4 specific aims with sub-aims
Expected outcomes and impact
Payoff paragraph: Why this matters

Structure for Each Aim:

Aim statement (1-2 sentences, starts with action verb)
Rationale (why this aim, preliminary data support)
Working hypothesis (testable prediction)
Approach summary (brief methods overview)
Expected outcomes and interpretation

Writing Strategy:

Make aims independent but complementary
Ensure each aim is achievable within timeline and budget
Provide enough detail to judge feasibility
Include contingency plans or alternative approaches
Use parallel structure across aims
Clearly state what will be learned from each aim

For detailed guidance, refer to references/specific_aims_guide.md.

4. Broader Impacts (NSF) / Significance (NIH)

Articulate the societal, educational, or translational value of the research.

NSF Broader Impacts (critical component, equal weight with Intellectual Merit):

NSF explicitly evaluates broader impacts. Address at least one of these areas:

Advancing discovery and understanding while promoting teaching, training, and learning
- Integration of research and education
- Training of students and postdocs
- Curriculum development
- Educational materials and resources
Broadening participation of underrepresented groups
- Recruitment and retention strategies
- Partnerships with minority-serving institutions
- Outreach to underrepresented communities
- Mentoring programs
Enhancing infrastructure for research and education
- Shared facilities or instrumentation
- Cyberinfrastructure and data resources
- Community-wide tools or databases
- Open-source software or methods
Broad dissemination to enhance scientific and technological understanding
- Public outreach and science communication
- K-12 educational programs
- Museum exhibits or media engagement
- Policy briefs or stakeholder engagement
Benefits to society
- Economic impact or commercialization
- Health, environment, or national security benefits
- Informed decision-making
- Workforce development

Writing Strategy for NSF Broader Impacts:

Be specific with concrete activities, not vague statements
Provide timeline and milestones for broader impacts activities
Explain how impacts will be measured and assessed
Connect to institutional resources and existing programs
Show commitment through preliminary efforts or partnerships
Integrate with research plan (not tacked on)

NIH Significance:

Addresses important problem or critical barrier to progress
Improves scientific knowledge, technical capability, or clinical practice
Potential to lead to better outcomes, interventions, or understanding
Rigor of prior research in the field
Alignment with NIH mission and institute priorities

For detailed guidance, refer to references/broader_impacts.md.

5. Innovation and Transformative Potential

Articulate what is novel, creative, and paradigm-shifting about the research.

Innovation Elements to Highlight:

Conceptual Innovation: New frameworks, models, or theories
Methodological Innovation: Novel techniques, approaches, or technologies
Integrative Innovation: Combining disciplines or approaches in new ways
Translational Innovation: New pathways from discovery to application
Scale Innovation: Unprecedented scope or resolution

Writing Strategy:

Clearly state what is innovative (don't assume it's obvious)
Explain why current approaches are insufficient
Describe how your innovation overcomes limitations
Provide evidence that innovation is feasible (preliminary data, proof-of-concept)
Distinguish incremental from transformative advances
Balance innovation with feasibility (not too risky)

Common Mistakes:

Claiming novelty without demonstrating knowledge of prior work
Confusing "new to me" with "new to the field"
Over-promising without supporting evidence
Being too incremental (minor variation on existing work)
Being too speculative (no path to success)

6. Research Approach and Methods

Detailed description of how the research will be conducted.

Essential Components:

Overall research design and framework
Detailed methods for each aim/objective
Sample sizes, statistical power, and analysis plans
Timeline and sequence of activities
Data collection, management, and analysis
Quality control and validation approaches
Potential problems and alternative strategies
Rigor and reproducibility measures

Writing Strategy:

Provide enough detail for reproducibility and feasibility assessment
Use subheadings and figures to improve organization
Justify choice of methods and approaches
Address potential limitations proactively
Include preliminary data demonstrating feasibility
Show that you've thought through the research process
Balance detail with readability (use supplementary materials for extensive details)

For Experimental Research:

Describe experimental design (controls, replicates, blinding)
Specify materials, reagents, and equipment
Detail data collection protocols
Explain statistical analysis plans
Address rigor and reproducibility

For Computational Research:

Describe algorithms, models, and software
Specify datasets and validation approaches
Explain computational resources required
Address code availability and documentation
Describe benchmarking and performance metrics

For Clinical or Translational Research:

Describe study population and recruitment
Detail intervention or treatment protocols
Explain outcome measures and assessments
Address regulatory approvals (IRB, IND, IDE)
Describe clinical trial design and monitoring

For detailed methodology guidance by discipline, refer to references/research_methods.md.

7. Preliminary Data and Feasibility

Demonstrate that the research is achievable and the team is capable.

Purpose:

Prove that the proposed approach can work
Show that the team has necessary expertise
Demonstrate access to required resources
Reduce perceived risk for reviewers
Provide foundation for proposed work

What to Include:

Pilot studies or proof-of-concept results
Method development or optimization
Access to unique resources (samples, data, collaborators)
Relevant publications from your team
Preliminary models or simulations
Feasibility assessments or power calculations

NIH Requirements:

R01 applications typically require substantial preliminary data
R21 applications may have less stringent requirements
New investigators may have less preliminary data
Preliminary data should directly support proposed aims

NSF Approach:

Preliminary data less commonly required than NIH
May be important for high-risk or novel approaches
Can strengthen proposal for competitive programs

Writing Strategy:

Present most compelling data that supports your approach
Clearly connect preliminary data to proposed aims
Acknowledge limitations and how proposed work will address them
Use figures and data visualizations effectively
Avoid over-interpreting or overstating preliminary findings
Show trajectory of your research program

8. Timeline, Milestones, and Management Plan

Demonstrate that the project is well-planned and achievable within the proposed timeframe.

Essential Elements:

Phased timeline with clear milestones
Logical sequence and dependencies
Realistic timeframes for each activity
Decision points and go/no-go criteria
Risk mitigation strategies
Resource allocation across time
Coordination plan for multi-institutional teams

Presentation Formats:

Gantt charts showing overlapping activities
Year-by-year breakdown of activities
Quarterly milestones and deliverables
Table of aims/tasks with timeline and personnel

Writing Strategy:

Be realistic about what can be accomplished
Build in time for unexpected delays or setbacks
Show that timeline aligns with budget and personnel
Demonstrate understanding of regulatory timelines (IRB, IACUC)
Include time for dissemination and broader impacts
Address how progress will be monitored and assessed

DARPA Emphasis:

Particularly important for DARPA proposals
Clear technical milestones with measurable metrics
Quarterly deliverables and reporting
Phase-based structure with exit criteria
Demonstration and transition planning

For detailed guidance, refer to references/timeline_planning.md.

9. Team Qualifications and Collaboration

Demonstrate that the team has the expertise, experience, and resources to succeed.

Essential Elements:

PI qualifications and relevant expertise
Co-I and collaborator roles and contributions
Track record in the research area
Complementary expertise across team
Institutional support and resources
Prior collaboration history (if applicable)
Mentoring and training plan (for students/postdocs)

Writing Strategy:

Highlight most relevant publications and accomplishments
Clearly define roles and responsibilities
Show that team composition is necessary (not just convenient)
Demonstrate successful prior collaborations
Address how team will be managed and coordinated
Explain institutional commitment and support

Biosketches / CVs:

Follow agency-specific formats (NSF, NIH, DOE, DARPA differ)
Highlight most relevant publications and accomplishments
Include synergistic activities and collaborations
Show trajectory and productivity
Address any career gaps or interruptions

Letters of Collaboration:

Specific commitments and contributions
Demonstrates genuine partnership
Includes resource sharing or access agreements
Signed and on letterhead

For detailed guidance, refer to references/team_building.md.

10. Budget and Budget Justification

Develop realistic budgets that align with the proposed work and agency guidelines.

Budget Categories (typical):

Personnel: Salary and fringe for PI, co-Is, postdocs, students, staff
Equipment: Items >$5,000 (varies by agency)
Travel: Conferences, collaborations, fieldwork
Materials and Supplies: Consumables, reagents, software
Other Direct Costs: Publication costs, participant incentives, consulting
Indirect Costs (F&A): Institutional overhead (rates vary)
Subawards: Costs for collaborating institutions

Agency-Specific Considerations:

NSF:

Full budget justification required
Cost sharing generally not required (but may strengthen proposal)
Up to 2 months summer salary for faculty
Graduate student support encouraged

NIH:

Modular budgets for ≤$250K direct costs per year (R01)
Detailed budgets for >$250K or complex awards
Salary cap applies (~$221,900 for 2024)
Limited to 1 month (8.33% FTE) for most PIs

DOE:

Often requires cost sharing (especially ARPA-E)
Detailed budget with quarterly breakdown
Requires institutional commitment letters
National laboratory collaboration budgets separate

DARPA:

Detailed budgets by phase and task
Requires supporting cost data for large procurements
Often requires cost-plus or firm-fixed-price structures
Travel budget for program meetings

Budget Justification Writing:

Justify each line item in terms of the research plan
Explain effort percentages for personnel
Describe specific equipment and why necessary
Justify travel (conferences, collaborations)
Explain consultant roles and rates
Show how budget aligns with timeline

For detailed budget guidance, refer to references/budget_preparation.md.

Review Criteria by Agency

Understanding how proposals are evaluated is critical for writing competitive applications.

NSF Review Criteria

Intellectual Merit (primary):

What is the potential for the proposed activity to advance knowledge?
How well-conceived and organized is the proposed activity?
Is there sufficient access to resources?
How well-qualified is the individual, team, or institution to conduct proposed activities?

Broader Impacts (equally important):

What is the potential for the proposed activity to benefit society?
To what extent does the proposal address broader impacts in meaningful ways?

Additional Considerations:

Integration of research and education
Diversity and inclusion
Results from prior NSF support (if applicable)

NIH Review Criteria

Scored Criteria (1-9 scale, 1 = exceptional, 9 = poor):

Significance
- Addresses important problem or critical barrier
- Improves scientific knowledge, technical capability, or clinical practice
- Aligns with NIH mission
Investigator(s)
- Well-suited to the project
- Track record of accomplishments
- Adequate training and expertise
Innovation
- Novel concepts, approaches, methodologies, or interventions
- Challenges existing paradigms
- Addresses important problem in creative ways
Approach
- Well-reasoned and appropriate
- Rigorous and reproducible
- Adequately accounts for potential problems
- Feasible within timeline
Environment
- Institutional support and resources
- Scientific environment contributes to probability of success

Additional Review Considerations (not scored but discussed):

Protections for human subjects
Inclusion of women, minorities, and children
Vertebrate animal welfare
Biohazards
Resubmission response (if applicable)
Budget and timeline appropriateness

DOE Review Criteria

Varies by program office, but generally includes:

Scientific and/or technical merit
Appropriateness of proposed method or approach
Competency of personnel and adequacy of facilities
Reasonableness and appropriateness of budget
Relevance to DOE mission and program goals

DARPA Review Criteria

DARPA-specific considerations:

Overall scientific and technical merit
Potential contribution to DARPA mission
Relevance to stated program goals
Plans and capability to accomplish technology transition
Qualifications and experience of proposed team
Realism of proposed costs and availability of funds

Key Questions DARPA Asks:

What if you succeed? (Impact if the research works)
What if you're right? (Implications of your hypothesis)
Who cares? (Why it matters for national security)

For detailed review criteria by agency, refer to references/review_criteria.md.

Writing Principles for Competitive Proposals

Clarity and Accessibility

Write for Multiple Audiences:

Technical reviewers in your field (will scrutinize methods)
Reviewers in related but not identical fields (need context)
Program officers (look for alignment with agency goals)
Panel members reading 15+ proposals (need clear organization)

Strategies:

Use clear section headings and subheadings
Start sections with overview paragraphs
Define technical terms and abbreviations
Use figures, diagrams, and tables to clarify complex ideas
Avoid jargon when possible; explain when necessary
Use topic sentences to guide readers

Persuasive Argumentation

Build a Compelling Narrative:

Establish the problem and its importance
Show gaps in current knowledge or approaches
Present your solution as innovative and feasible
Demonstrate that you're the right team
Show that success will have significant impact

Structure of Persuasion:

Hook: Capture attention with significance
Problem: Establish what's not known or not working
Solution: Present your innovative approach
Evidence: Support with preliminary data
Impact: Show transformative potential
Team: Demonstrate capability to deliver

Language Choices:

Use active voice for clarity and confidence
Choose strong verbs (investigate, elucidate, discover vs. look at, study)
Be confident but not arrogant (avoid "obviously," "clearly")
Acknowledge uncertainty appropriately
Use precise language (avoid vague terms like "several," "various")

Visual Communication

Effective Use of Figures:

Conceptual diagrams showing research framework
Preliminary data demonstrating feasibility
Timelines and Gantt charts
Workflow diagrams showing methodology
Expected results or predictions

Design Principles:

Make figures self-explanatory with complete captions
Use consistent color schemes and fonts
Ensure readability (large enough fonts, clear labels)
Integrate figures with text (refer to specific figures)
Follow agency-specific formatting requirements

Addressing Risk and Feasibility

Balance Innovation and Risk:

Acknowledge potential challenges
Provide alternative approaches
Show preliminary data reducing risk
Demonstrate expertise to handle challenges
Include contingency plans

Common Concerns:

Too ambitious for timeline/budget
Technically infeasible
Team lacks necessary expertise
Preliminary data insufficient
Methods not adequately described
Lack of innovation or significance

Integration and Coherence

Ensure All Parts Align:

Budget supports activities in project description
Timeline matches aims and milestones
Team composition matches required expertise
Broader impacts connect to research plan
Letters of support confirm stated collaborations

Avoid Contradictions:

Preliminary data vs. stated gaps
Claimed expertise vs. publication record
Stated aims vs. actual methods
Budget vs. stated activities

Common Proposal Types

NSF Proposal Types

Standard Research Proposals: Most common, up to $500K and 5 years
CAREER Awards: Early career faculty, integrated research/education, $400-500K over 5 years
Collaborative Research: Multiple institutions, separately submitted, shared research plan
RAPID: Urgent research opportunities, up to $200K, no preliminary data required
EAGER: High-risk, high-reward exploratory research, up to $300K
EArly-concept Grants for Exploratory Research (EAGER): Early-stage exploratory work

NIH Award Mechanisms

R01: Research Project Grant, $250K+ per year, 3-5 years, most common
R21: Exploratory/Developmental Research, up to $275K over 2 years, no preliminary data
R03: Small Grant Program, up to $100K over 2 years
R15: Academic Research Enhancement Awards (AREA), for primarily undergraduate institutions
R35: MIRA (Maximizing Investigators' Research Award), program-specific
P01: Program Project Grant, multi-project integrated research
U01: Research Project Cooperative Agreement, NIH involvement in conduct

Fellowship Mechanisms:

F30: Predoctoral MD/PhD Fellowship
F31: Predoctoral Fellowship
F32: Postdoctoral Fellowship
K99/R00: Pathway to Independence Award
K08: Mentored Clinical Scientist Research Career Development Award

DOE Programs

Office of Science: Basic research in physical sciences, biological sciences, computing
ARPA-E: Transformative energy technologies, requires cost sharing
EERE: Applied research in renewable energy and energy efficiency
National Laboratories: Collaborative research with DOE labs

DARPA Programs

Varies by Office: BTO, DSO, I2O, MTO, STO, TTO
Program-Specific BAAs: Broad Agency Announcements for specific thrusts
Young Faculty Award (YFA): Early career researchers, up to $500K
Director's Fellowship: High-risk, paradigm-shifting research

For detailed program guidance, refer to references/funding_mechanisms.md.

Resubmission Strategies

NIH Resubmission (A1)

Introduction to Resubmission (1 page):

Summarize major criticisms from previous review
Describe specific changes made in response
Use bullet points for clarity
Be respectful of reviewers' comments
Highlight substantial improvements

Strategies:

Address every major criticism
Make changes visible (but don't use track changes in final)
Strengthen weak areas (preliminary data, methods, significance)
Consider changing aims if fundamentally flawed
Get external feedback before resubmitting
Use full 37-month window if needed for new data

When Not to Resubmit:

Fundamental conceptual flaws
Lack of innovation or significance
Missing key expertise or resources
Extensive revisions needed (consider new submission)

NSF Resubmission

NSF allows resubmission after revision:

Address reviewer concerns in revised proposal
No formal "introduction to resubmission" section
May be reviewed by same or different panel
Consider program officer feedback
May need to wait for next submission cycle

For detailed resubmission guidance, refer to references/resubmission_strategies.md.

Common Mistakes to Avoid

Conceptual Mistakes

Failing to Address Review Criteria: Not explicitly discussing significance, innovation, approach, etc.
Mismatch with Agency Mission: Proposing research that doesn't align with agency goals
Unclear Significance: Failing to articulate why the research matters
Insufficient Innovation: Incremental work presented as transformative
Vague Objectives: Goals that are not specific or measurable

Writing Mistakes

Poor Organization: Lack of clear structure and flow
Excessive Jargon: Inaccessible to broader review panel
Verbosity: Unnecessarily complex or wordy writing
Missing Context: Assuming reviewers know your field deeply
Inconsistent Terminology: Using different terms for same concept

Technical Mistakes

Inadequate Methods: Insufficient detail to judge feasibility
Overly Ambitious: Too much proposed for timeline/budget
No Preliminary Data: For mechanisms requiring demonstrated feasibility
Poor Timeline: Unrealistic or poorly justified schedule
Misaligned Budget: Budget doesn't support proposed activities

Formatting Mistakes

Exceeding Page Limits: Automatic rejection
Wrong Font or Margins: Non-compliant formatting
Missing Required Sections: Incomplete application
Poor Figure Quality: Illegible or unprofessional figures
Inconsistent Citations: Formatting errors in references

Strategic Mistakes

Wrong Program or Mechanism: Proposing to inappropriate opportunity
Weak Team: Insufficient expertise or missing key collaborators
No Broader Impacts: For NSF, failing to adequately address
Ignoring Program Priorities: Not aligning with current emphasis areas
Late Submission: Technical issues or rushed preparation

Workflow for Grant Development

Phase 1: Planning and Preparation (2-6 months before deadline)

Activities:

Identify appropriate funding opportunities
Review program announcements and requirements
Consult with program officers (if appropriate)
Assemble team and confirm collaborations
Develop preliminary data (if needed)
Outline research plan and specific aims
Review successful proposals (if available)

Outputs:

Selected funding opportunity
Assembled team with defined roles
Preliminary outline of specific aims
Gap analysis of needed preliminary data

Phase 2: Drafting (2-3 months before deadline)

Activities:

Write specific aims or objectives (start here!)
Develop project description/research strategy
Create figures and data visualizations
Draft timeline and milestones
Prepare preliminary budget
Write broader impacts or significance sections
Request letters of support/collaboration

Outputs:

Complete first draft of narrative sections
Preliminary budget with justification
Timeline and management plan
Requested letters from collaborators

Phase 3: Internal Review (1-2 months before deadline)

Activities:

Circulate draft to co-investigators
Seek feedback from colleagues and mentors
Request institutional review (if required)
Mock review session (if possible)
Revise based on feedback
Refine budget and budget justification

Outputs:

Revised draft incorporating feedback
Refined budget aligned with revised plan
Identified weaknesses and mitigation strategies

Phase 4: Finalization (2-4 weeks before deadline)

Activities:

Final revisions to narrative
Prepare all required forms and documents
Finalize budget and budget justification
Compile biosketches, CVs, and current & pending
Collect letters of support
Prepare data management plan (if required)
Write project summary/abstract
Proofread all materials

Outputs:

Complete, polished proposal
All required supplementary documents
Formatted according to agency requirements

Phase 5: Submission (1 week before deadline)

Activities:

Institutional review and approval
Upload to submission portal
Verify all documents and formatting
Submit 24-48 hours before deadline
Confirm successful submission
Receive confirmation and proposal number

Outputs:

Submitted proposal
Submission confirmation
Archived copy of all materials

Critical Tip: Never wait until the deadline. Portals crash, files corrupt, and emergencies happen. Aim for 48 hours early.

Integration with Other Skills

This skill works effectively with:

Scientific Writing: For clear, compelling prose
Literature Review: For comprehensive background sections
Peer Review: For self-assessment before submission
Research Lookup: For finding relevant citations and prior work
Data Visualization: For creating effective figures

Resources

This skill includes comprehensive reference files covering specific aspects of grant writing:

references/nsf_guidelines.md: NSF-specific requirements, formatting, and strategies
references/nih_guidelines.md: NIH mechanisms, review criteria, and submission requirements
references/doe_guidelines.md: DOE programs, emphasis areas, and application procedures
references/darpa_guidelines.md: DARPA BAAs, program offices, and proposal strategies
references/broader_impacts.md: Strategies for compelling broader impacts statements
references/specific_aims_guide.md: Writing effective specific aims pages
references/budget_preparation.md: Budget development and justification
references/review_criteria.md: Detailed review criteria by agency
references/timeline_planning.md: Creating realistic timelines and milestones
references/team_building.md: Assembling and presenting effective teams
references/resubmission_strategies.md: Responding to reviews and revising proposals

Load these references as needed when working on specific aspects of grant writing.

Templates and Assets

assets/nsf_project_summary_template.md: NSF project summary structure
assets/nih_specific_aims_template.md: NIH specific aims page template
assets/timeline_gantt_template.md: Timeline and Gantt chart examples
assets/budget_justification_template.md: Budget justification structure
assets/biosketch_templates/: Agency-specific biosketch formats

Scripts and Tools

scripts/compliance_checker.py: Verify formatting requirements
scripts/budget_calculator.py: Calculate budgets with inflation and fringe
scripts/deadline_tracker.py: Track submission deadlines and milestones

Final Note: Grant writing is both an art and a science. Success requires not only excellent research ideas but also clear communication, strategic positioning, and meticulous attention to detail. Start early, seek feedback, and remember that even the best researchers face rejection—persistence and revision are key to funding success.

About this skill

Automatic

Research pack

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 7/30/2026

View 15 scanner checks

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

FreedomIntelligence / OpenClaw-Medical-Skills

skills/research-grants/SKILL.md

View on GitHub ↗

Imported 8/1/2026Version v1Bundled 9 files

Illustrative Want to see what research-grants would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Other skills for the same job

Published skills whose descriptions closely match this one, with their headline benchmark lift.

Related skills

Skills that do similar work, with their headline benchmark lift.

mohitagw15856/grant-proposalWrite a structured grant proposal or funding application for any grant type. Use when asked to write a grant proposal, funding application, research grant, charitable grant, or innovation fund application. Produces a complete proposal with project summary, rationale, methodology, impact, and budget narrative.+45 pts pass-rate lift

From the same source and nearby in the catalogue.

Ready to supercharge your AI agents?

Safety

What it changes

Track record

Use this skill

Research Grant Writing

Overview

When to Use This Skill

Visual Enhancement with Scientific Schematics

Agency-Specific Overview

NSF (National Science Foundation)

NIH (National Institutes of Health)

DOE (Department of Energy)

DARPA (Defense Advanced Research Projects Agency)

Core Components of Research Proposals

1. Executive Summary / Project Summary / Abstract

2. Project Description / Research Strategy

3. Specific Aims (NIH) or Objectives (NSF/DOE/DARPA)

4. Broader Impacts (NSF) / Significance (NIH)

5. Innovation and Transformative Potential

6. Research Approach and Methods

7. Preliminary Data and Feasibility

8. Timeline, Milestones, and Management Plan

9. Team Qualifications and Collaboration

10. Budget and Budget Justification

Review Criteria by Agency

NSF Review Criteria

NIH Review Criteria

DOE Review Criteria

DARPA Review Criteria

Writing Principles for Competitive Proposals

Clarity and Accessibility

Persuasive Argumentation

Visual Communication

Addressing Risk and Feasibility

Integration and Coherence

Common Proposal Types

NSF Proposal Types

NIH Award Mechanisms

DOE Programs

DARPA Programs

Resubmission Strategies

NIH Resubmission (A1)

NSF Resubmission

Common Mistakes to Avoid

Conceptual Mistakes

Writing Mistakes

Technical Mistakes

Formatting Mistakes

Strategic Mistakes

Workflow for Grant Development

Phase 1: Planning and Preparation (2-6 months before deadline)

Phase 2: Drafting (2-3 months before deadline)

Phase 3: Internal Review (1-2 months before deadline)

Phase 4: Finalization (2-4 weeks before deadline)

Phase 5: Submission (1 week before deadline)

Integration with Other Skills

Resources

Templates and Assets

Scripts and Tools

SkillSafety

Source

Other skills for the same job

Related skills

More in the registry