Try with Your Own Business Files
Summary of This Page
You can replace the sample data with your own files to verify the feasibility of business application in 90 minutes.
- Replacement steps by business theme (manual search / meeting minutes / design document review / test design)
- A clear distinction between what you can change and what you should not change
- Six evaluation criteria for judging output quality
By reading this page, you will have what you need to judge whether Agentiqs is worth adopting.
Overview
This page explains how to replace the sample data with your own business files and try it in 90 minutes, after you have checked the Agentiqs sample data.
Running the sample data lets you quickly check what Agentiqs can do.
However, to actually judge the benefits of adoption, it is important to try it using your own manuals, FAQs, meeting notes, design documents, review perspectives, and past findings.
In this 90-minute course, instead of substantially rebuilding the samples, you will first replace only the input files with your own business files.
You will then check the output results and, as needed, gradually adjust the questions, review perspectives, AI agents, and workflows.
The purpose of this page is to help evaluation version users quickly judge whether "Agentiqs seems usable for our own business operations."
What You Will Learn on This Page
This page explains the following:
- The purpose of trying Agentiqs with your own business files
- The goals to check in 90 minutes
- The files to prepare in advance
- Which sample to use as a base
- The steps for replacing files with your own files
- How to try it by business theme
- How to evaluate the output results
- Common pitfalls and how to address them
- What to organize after the 90 minutes
- Which page to go to next
Goals of This 90-Minute Course
The goal of this 90-minute course is to check, on a small scale, whether Agentiqs can be applied to your own business operations.
By the end of the 90 minutes, you should be able to judge the following.
| Goal | Description |
|---|---|
| Check whether it works with your own files | You can replace the sample input data with your own files and run it |
| Check the output quality | You can check whether the answers, meeting minutes, review findings, and test items seem usable in practice |
| Understand the adjustment points | You understand which of the input file, question, review perspectives, or output format should be improved |
| Decide candidate use cases | You can identify at least one business theme to apply first in your organization |
| Decide the next action | You can decide the next step, such as creating an AI agent, creating a workflow, or organizing knowledge |
The Value of Agentiqs You Will Confirm in This Course
By trying it with your own business files, you can confirm the following.
| Value to Confirm | Description |
|---|---|
| Using your own documents | Whether the AI can work with manuals, specifications, FAQs, and similar documents |
| Generating business deliverables | Whether deliverables can be created from meeting notes, design documents, review findings, and similar inputs |
| Review support | Whether your own design documents can be checked according to review perspectives |
| Practicality of the output | Whether the output is provided in a form that is easy for people to check and revise |
| Ease of replacement | Whether the samples seem adjustable for your own business operations |
| Business impact | Whether it seems likely to shorten investigation time, improve document creation efficiency, and prevent review omissions |
Target Audience
This page is intended for the following users.
- Users who have run the sample data and now want to try it with their own data
- Users who want to check whether Agentiqs can be applied to their own business operations
- Users who want to evaluate it using manuals, FAQs, meeting notes, design documents, review findings, and similar materials
- Users who want to try it on a small scale first, before creating AI agents or workflows
- Users considering applying it to design, review, test design, inquiry handling, and similar tasks
- Users who want to explain the evaluation results to their manager or team
What to Complete in Advance
Before trying Agentiqs with your own business files, we recommend completing the following.
| Check Item | Description |
|---|---|
| Starting Agentiqs | Agentiqs is in a usable state |
| Chatting with AI | The AI provider settings have been completed |
| Sample data placement | The sample data has been placed in the specified folder |
| Importing sample settings | The sample AI agents, workflows, and tool settings are available |
| Running the related sample | You have already run the sample to be replaced, using the bundled data as-is |
| Preparing your own files | You have prepared a copy of your own files for verification |
If you have not yet run the samples, check the following first.
Files to Prepare First
For your first try, we recommend choosing one file from the following.
| Business Theme | Files to Prepare | Corresponding Sample |
|---|---|---|
| Document search | Product manuals, specifications, FAQs | Search Across a Large Volume of Documents |
| Meeting minutes creation | Meeting notes | Automatically Generate Meeting Minutes |
| Design document review | Functional design documents, detailed design documents, API specifications | Review a Design Document Based on Review Perspectives |
| Rigorous review | Design documents organized by chapter, review perspective tables | Rigorous Review of Design Documents by Review Points |
| Test design | Design documents, test perspective tables | Generate Test Design from Design Documents |
| Review perspective creation | List of past review findings | Extracting Perspectives from Review Findings |
| Model review | A copy of a Next Design project | Review Next Design Models by Review Points |
| Issue registration | A Lightning Review file for verification | Automatically Register Review Findings to Lightning Review |
Recommended Conditions for Your First Try
When trying it with your own files for the first time, use the following conditions.
| Item | Recommendation |
|---|---|
| Number of files | 1 file |
| Document length | About 5-20 pages |
| Theme | Limit to one theme |
| Scope | One feature, one chapter, one meeting, one review, etc. |
| Review perspectives | 3-5 perspectives |
| Output destination | A verification folder, verification Excel file, or verification Markdown file |
| External tools | Use a copy or verification data for the first try, not production data |
| Evaluation method | Something you can compare against existing deliverables or expert review |
Things to Avoid at First
In your first evaluation with your own files, avoid the following.
| Things to Avoid | Reason |
|---|---|
| Using a large volume of documents at once | It becomes harder to isolate the cause if the output differs from what you expect |
| Mixing documents from multiple themes | It becomes harder for the AI to judge which information to prioritize |
| Directly updating production files | Unexpected results may remain in the file |
| Registering directly to a production review or production project | Unnecessary findings or models may remain |
| Substantially changing the sample workflow | It becomes harder to identify the cause if it stops working |
| Evaluating with material whose correct answer is unknown | You cannot judge the validity of the output |
| Mixing old and new documents | The AI may answer based on outdated information |
Start by making use of the sample's structure and replacing only the input data.
90-Minute Course Details
Overall Timetable
If you proceed in the following order, you can quickly check the feasibility of applying it to your own business operations.
| Time | Activity | Purpose |
|---|---|---|
| 0–10 min | Decide the evaluation theme and your own files | Narrow down what to try |
| 10–20 min | Check the sample to be replaced | Confirm normal operation and the input/output |
| 20–35 min | Replace with your own files | Replace only the input data |
| 35–55 min | Run it and check the output | See the output quality with your own data |
| 55–70 min | Adjust the question, perspectives, and output format | Make it easier to use in practice |
| 70–80 min | Run it again and check the improvement | See the effect of the adjustments |
| 80–90 min | Organize the evaluation results and next actions | Decide the policy for continued verification |
0–10 Minutes: Decide the Evaluation Theme and Your Own Files
First, narrow down the theme you will try in this 90-minute session to just one.
How to Choose a Theme
Choose based on the following perspectives.
| Perspective | What to Check |
|---|---|
| The business impact is easy to understand | Whether it is easy to explain time savings, quality improvement, prevention of omissions, etc. |
| Input data is easy to prepare | Whether you can quickly prepare files for verification |
| You can judge the quality of the output | Whether the person in charge of the business can confirm its validity |
| Close to a sample | Whether it is close to the input/output of an existing sample |
| Can be tried on a small scale | Whether it can be narrowed down to one file, one feature, one meeting, etc. |
Recommended Themes
For your first try, we recommend one of the following.
| Theme | Reason |
|---|---|
| Searching your own manuals | The impact is easy to understand, and it is easy to evaluate through questions |
| Creating meeting minutes from your own meeting notes | It is easy to check the correspondence between input and output |
| Reviewing your own design documents | It is easy to confirm the kind of business support value Agentiqs is known for |
| Generating test items from your own design documents | It is easy to confirm the value of working across processes |
| Extracting perspectives from past review findings | It is easy to confirm the value of using existing assets |
Example Record of the Evaluation Theme
# Evaluation Notes for Your Own Business Files
## Evaluation Theme
Check whether a design document can be reviewed according to review perspectives.
## Your Own Files Used
- Temperature_Monitoring_Function_Detailed_Design.docx
- Design_Review_Perspectives.xlsx
## Expected Output
- List of review findings
- Reason for each finding
- Severity
- Items to confirm
- Improvement proposal
## Evaluation Perspectives
- Whether the findings are valid in practice
- Whether they are based on the content of the design document
- Whether they follow your own review perspectives
- Whether the format is easy for people to check
10–20 Minutes: Check the Sample to Be Replaced
Before replacing with your own files, be sure to check the sample to be replaced using the bundled data as-is.
What to Check
| Check Item | Description |
|---|---|
| Input file | What is used as the input |
| Additional data | Whether there are review perspectives, output formats, configuration files, etc. |
| Processing flow | What the AI agent or workflow does |
| Output destination | Where the results are output |
| Output format | Markdown, Excel, Lightning Review, etc. |
| Parts that are easy to change | Which file should be replaced |
| Parts that should not be changed | Which settings should not be touched the first time |
Replacement Points by Sample
| Sample | What to Replace First | What Not to Change the First Time |
|---|---|---|
| Search Across a Large Volume of Documents | Documents registered as knowledge | Basic AI agent settings |
| Automatically Generate Meeting Minutes | Meeting notes | Output format, workflow structure |
| Review a Design Document Based on Review Perspectives | Design document, review perspectives | Output format, basic AI agent prompt |
| Rigorous Review of Design Documents by Review Points | Design document, review perspectives | Chapter-splitting and perspective-loop structure |
| Generate Test Design from Design Documents | Design document, test perspectives | Output format, generation rules |
| Extracting Perspectives from Review Findings | List of past review findings | Perspective output format |
| Review Next Design Models by Review Points | Next Design project for verification | Production project, metamodel structure |
| Automatically Register Review Findings to Lightning Review | Design document and LR file for verification | Registration to a production review |
20–35 Minutes: Replace with Your Own Files
Once you have checked the structure of the sample, replace it with your own files.
For your first try, keep the number of changes as small as possible.
Change:
- Input file
- Review perspectives, if needed
- Output destination
Do not change:
- Overall workflow structure
- Basic AI agent prompt
- External tool integration settings
- Output format
Basic Steps for Replacing Your Own Files
- Check the sample's input folder
- Copy your own file for verification
- Place it in the same location as the sample's input file, or in the specified location
- Specify the file name or path in the settings
- Set the output destination to a verification folder
- Run the workflow or AI agent
Notes on Using Your Own Files
| Note | Description |
|---|---|
| Use a copy | Use a copy for verification, not the production file |
| Use clear file names | This makes it easier to check the output and isolate causes |
| Limit the amount of content | For the first try, limit it to about one chapter, one feature, or one meeting |
| Check for confidential information | Handle it according to your internal rules |
| Separate the output destination | Do not mix sample output with your own evaluation output |
| Do not overwrite existing files | Use a new file or a verification file as the output destination |
35–55 Minutes: Run It and Check the Output
Once you have replaced the files with your own, run it and check the output results.
At this stage, you do not need to expect a perfect output.
First, check whether your own files are read correctly and whether you get the expected type of output.
What to Check
| Check Item | Description |
|---|---|
| Input reading | Whether the content of your own file is read correctly |
| Process execution | Whether it runs through the same flow as the sample |
| Output generation | Whether the expected file or result is output |
| Validity of the content | Whether the output content is meaningful in practice |
| Evidence basis | Whether it is based on the content of your own file |
| Excessive guessing | Whether it asserts content that is not in the file |
| Ease of revision | Whether the format is easy for people to check and revise |
Evaluation Criteria for the Output
| Evaluation Perspective | Good State | State That Needs Improvement |
|---|---|---|
| Accuracy | Does not contradict the content of the input file | Asserts content that is not in the input |
| Specificity | Output at a level of detail usable for the next task | Mostly generalities, with low specificity |
| Structure | Tables, headings, and items are well organized | Long text that is hard to read |
| Evidence basis | The relevant section and reason are clear | It is unclear why that judgment was made |
| Practical usability | Usable as a draft | Requires too much revision |
| Reusability | Seems usable repeatedly for the same task | Seems to need major adjustment every time |
55–70 Minutes: Adjust the Question, Perspectives, and Output Format
Once you have checked the output, make adjustments as needed.
For your first adjustment, adjust the question, review perspectives, and output format, rather than making major changes to the AI agent or the workflow as a whole.
Items That Are Easy to Adjust
| Item to Adjust | Example Adjustment |
|---|---|
| Question | Clarify the target, conditions, and output format |
| Review perspectives | Make the perspectives more specific to match your own standards |
| Output format | Specify a table, checklist, FAQ format, etc. |
| Scope | Narrow it down to a specific chapter or feature instead of the whole document |
| Severity | Specify the criteria for High, Medium, and Low |
| Suppressing guesses | Specify that content not described should not be asserted |
| Items to confirm | Have unclear points output as items to confirm, not as issues |
Examples of Improving the Question
For Document Search
Before improvement:
Please tell me about this manual.
After improvement:
Based on the manual content included in the selected knowledge, organize the items that should be checked during initial setup.
Please output it in the following table format.
| Check Item | Description | Notes | Section to Refer To |
For Meeting Minutes Creation
Before improvement:
Please create meeting minutes.
After improvement:
Please create meeting minutes based on the attached meeting notes.
Please organize the following separately.
- Meeting overview
- Discussion details
- Decisions
- ToDos
- Open items
Do not guess and supplement any content that is not in the notes. Mark it as "Not stated" instead.
For Design Document Review
Before improvement:
Please review this design document.
After improvement:
Please review the attached design document from the following perspectives.
- Clarity of specifications
- Exception cases
- Boundary values
- State transitions
- Testability
Base each finding on content actually described in the design document.
Do not guess and assert content that is not described.
If there is not enough information to judge, output it as an item to confirm.
Please output it in the following table format.
| No | Perspective | Relevant Section | Issue | Reason for the Issue | Severity | Items to Confirm | Improvement Proposal |
For Test Design
Before improvement:
Please create test cases.
After improvement:
Please create a draft test design based on the attached design document.
Please include the following.
- Test perspectives
- Test conditions
- Input values
- Operation
- Expected result
- Specifications to confirm
- Unclear points
If the expected result is not clearly stated in the design document, do not guess and supplement it; output it as an item to confirm instead.
70–80 Minutes: Run It Again and Check the Improvement
Once you have adjusted the question and perspectives, run it again and check the improvement.
What to Compare
| Comparison Item | What to Check |
|---|---|
| Accuracy | Whether the output is now based on the input file |
| Specificity | Whether the content has become more usable in practice |
| Structure | Whether the tables and items are now organized |
| Suppression of guesses | Whether it has stopped asserting content that is not described |
| Severity | Whether the priority of findings and items has become clearer |
| Items to confirm | Whether unclear points have been organized as items to confirm |
Example Record of the Improvement
## First Output
### What Was Good
- The content of the design document was read correctly
- It was able to point out missing exception handling
### Points of Concern
- The reasons for the findings were somewhat generic
- The relevant section was hard to identify
- It slightly guessed at content that was not in the design document
## Adjustments Made
- Specified explicitly to "base findings on content described in the design document"
- Added a "Relevant Section" column to the output
- Set unclear points to be output as "Items to Confirm"
## Second Output
### What Improved
- The reasons for the findings became more specific
- The relevant section became easier to identify
- There was less guessing
### What Still Needs Improvement
- Want to align the severity criteria with our own rules
80–90 Minutes: Organize the Evaluation Results and Next Actions
Finally, organize the results of your 90-minute evaluation.
What to Organize as Evaluation Results
| Item | Description |
|---|---|
| Business theme tried | Which business task you tried it on |
| Your own files used | Which files you used |
| Sample used as the base | Which sample you used as the base |
| What was good | Points that seem usable in business |
| Points of concern | Points that need improvement |
| What to adjust next | Perspectives, prompts, output format, workflow, etc. |
| Whether it can be applied | Whether to continue verifying or try a different theme |
| Next action | Creating an AI agent, building a workflow, team evaluation, etc. |
Evaluation Results Notes Template
# Evaluation Results for Your Own Business Files
## Evaluation Theme
-
## Your Own Files Used
-
## Sample Used as the Base
-
## What Was Run
-
## What Was Good
-
-
-
## Points of Concern
-
-
-
## Evaluation of Output Quality
| Evaluation Perspective | Rating | Comment |
|---|---|---|
| Accuracy | | |
| Specificity | | |
| Evidence basis | | |
| Structure | | |
| Practical usability | | |
| Reusability | | |
## Can It Be Applied to Your Own Business?
-
## What to Adjust Next
- [ ] Organize the input files
- [ ] Align the review perspectives with your own standards
- [ ] Create an AI agent
- [ ] Adjust the workflow
- [ ] Align the output format with your own forms
- [ ] Have team members try it
## Next Action
-
How to Try It by Business Theme
From here, this section explains how to try Agentiqs with your own files, organized by business theme.
Trying It with Your Own Manuals and FAQs
This is the flow for trying knowledge utilization using your own product manuals, FAQs, and inquiry-response materials.
Corresponding Sample
Files to Prepare
| File | Description |
|---|---|
| Product manual | Feature descriptions, operating procedures, constraints |
| FAQ | Frequently asked questions and answers |
| Inquiry response notes | Items to check during inquiries, example answers |
| Glossary | Definitions of terms used in the product or business |
Example Questions to Try
Based on the selected knowledge, please tell me the setup steps for this feature.
If a user submits an inquiry saying "it doesn't work even after I configured it," organize what should be checked first.
Please organize the precautions for using this feature in table format.
| Precaution | Reason | Information to Refer To |
Do not guess any content that is not described in the knowledge. Reply with "This cannot be confirmed in the knowledge."
Evaluation Points
| Evaluation Perspective | What to Check |
|---|---|
| Document reference | Whether the answer is based on the manual or FAQ |
| Answer quality | Whether it can be used as a draft support answer |
| Handling of unclear points | Whether it asserts content that is not described |
| Business impact | Whether it seems likely to shorten investigation time or answer-drafting time |
Trying It with Your Own Meeting Notes
This is the flow for trying meeting minutes generation using your own meeting notes.
Corresponding Sample
Files to Prepare
| File | Description |
|---|---|
| Meeting notes | Discussion content, remarks, decisions, ToDos |
| Meeting minutes format | The meeting minutes format used in your organization |
| Past meeting minutes | Meeting minutes used as a reference for the output |
Example Requests to Try
Please create meeting minutes based on the attached meeting notes.
Please organize the following separately.
- Meeting overview
- Discussion details
- Decisions
- ToDos
- Open items
Please extract the ToDos in the following table format.
| No | ToDo | Owner | Due Date | Notes |
Do not guess and supplement any content that is not in the meeting notes. Mark it as "Not stated" instead.
Evaluation Points
| Evaluation Perspective | What to Check |
|---|---|
| Information extraction | Whether decisions and ToDos are extracted correctly |
| Structure | Whether it is organized to be readable as meeting minutes |
| Suppression of supplementation | Whether content not in the notes is added on its own |
| Practical usability | Whether it is a draft usable with minor revisions |
Trying Review with Your Own Design Documents
This is the flow for trying AI-assisted review using your own design documents and specifications.
Corresponding Samples
- Review a Design Document Based on Review Perspectives
- Rigorous Review of Design Documents by Review Points
- Creating an AI Agent Specialized for Reviews
Files to Prepare
| File | Description |
|---|---|
| Design document | Functional design documents, detailed design documents, API specifications, etc. |
| Review perspectives | Your own checklists, quality standards, review criteria |
| Past review findings | Used as a point of comparison during evaluation |
| Design standards | Used as knowledge if needed |
Example Requests to Try
Please review the attached design document according to the attached review perspectives.
Be sure to output the following.
- Issue
- Relevant section
- Reason for the issue
- Severity
- Items to confirm
- Improvement proposal
Please review it from the perspective of test design.
Point out the input conditions, expected results, boundary values, exception cases, and state transition conditions that are missing for creating test items.
Base your findings on content described in the design document.
Do not guess and assert content that is not described; output it as an item to confirm instead.
Evaluation Points
| Evaluation Perspective | What to Check |
|---|---|
| Validity of the findings | Whether they are meaningful as actual review findings |
| Fit with the perspectives | Whether they follow your own review perspectives |
| Evidence basis | Whether they are based on the content of the design document |
| Severity | Whether the priority judgment matches practical experience |
| Practical usability | Whether it seems usable for self-checks or first-pass reviews |
Trying Test Design from Your Own Design Documents
This is the flow for trying the generation of test perspectives and test items based on a design document.
Corresponding Sample
Files to Prepare
| File | Description |
|---|---|
| Design document | A document describing the specification to be tested |
| Test perspectives | Your own test design standards and checkpoints |
| Existing test cases | Used as a point of comparison during evaluation |
Example Requests to Try
Please create a draft test design based on the attached design document.
Please include the following.
- Test perspectives
- Test conditions
- Input values
- Operation
- Expected result
- Specifications to confirm
- Unclear points
If the expected result is not clearly stated in the design document, do not guess and supplement it; output it as an item to confirm instead.
Evaluation Points
| Evaluation Perspective | What to Check |
|---|---|
| Test perspectives | Whether the necessary perspectives are extracted |
| Expected results | Whether the expected results are based on the design document |
| Unclear points | Whether gaps in the design document are output as items to confirm |
| Practical usability | Whether it seems usable as a draft test design |
Trying It with Past Review Findings
This is the flow for creating review perspectives and checklists based on past review findings.
Corresponding Sample
Files to Prepare
| File | Description |
|---|---|
| List of past review findings | Findings, categories, causes, responses, etc. |
| Review criteria | Your own review perspectives and quality standards |
| Failure reports | Used when creating recurrence-prevention perspectives |
Example Requests to Try
Please analyze the attached list of past review findings and extract review perspectives that can be used in future design document reviews.
Please output it in the following table format.
| No | Review Perspective | What to Check | Example Finding | Severity |
Please classify the frequently occurring finding patterns and create a checklist for preventing recurrence.
Evaluation Points
| Evaluation Perspective | What to Check |
|---|---|
| Finding trends | Whether the trends in past findings are captured |
| Conversion to perspectives | Whether they become review perspectives usable going forward |
| Reusability | Whether it seems usable as a team checklist |
| Practical impact | Whether it seems likely to lead to standardized review quality |
Trying It with a Next Design Project
This is the flow for evaluating it using design models in Next Design.
Corresponding Samples
What to Prepare
| What to Prepare | Description |
|---|---|
| Next Design project for verification | A copy of the production project, or an evaluation project |
| Target model | Requirement models, function models, state models, etc. |
| Review perspectives | Perspectives used in the model review |
| Expected output | Review findings, test case models, etc. |
How to Proceed the First Time
- Confirm the behavior with the sample project
- Copy your own project
- Narrow the target models down to 1-5
- Run it while keeping the sample settings as unchanged as possible
- Check the output results
Evaluation Points
| Evaluation Perspective | What to Check |
|---|---|
| Model retrieval | Whether the model in Next Design can be retrieved |
| Model understanding | Whether it can process based on the model name, attributes, description, and relations |
| Validity of the findings | Whether they are meaningful as a model review |
| Deliverable generation | Whether test cases or review findings can be created |
| Application to your organization | Whether it seems adaptable to your own metamodel |
Trying It with a Lightning Review File
This is the flow for registering review findings extracted by AI into Lightning Review.
Corresponding Sample
What to Prepare
| What to Prepare | Description |
|---|---|
| Lightning Review file for verification | A copy or sample, not the production review |
| Design document to be reviewed | The design document from which findings are extracted |
| Review perspectives | Perspectives used to extract findings |
| Target review | The review to which findings are registered |
How to Proceed the First Time
- Confirm the behavior with the sample Lightning Review file
- Prepare a Lightning Review file for verification
- Replace the design document and review perspectives
- Narrow the scope so the number of registered findings does not become too large
- Check the registration results in Lightning Review
Evaluation Points
| Evaluation Perspective | What to Check |
|---|---|
| Whether registration succeeds | Whether the findings can be registered in Lightning Review |
| Quality of the findings | Whether the registered findings are meaningful in practice |
| Registration format | Whether the issue, severity, and items to confirm are easy to check |
| Duplicates | Whether there are unnecessary duplicate findings |
| Business impact | Whether it seems likely to reduce the work of registering findings |
Common Pitfalls and Solutions
| Pitfall | Common Cause | Solution |
|---|---|---|
| Your own file cannot be read | A problem with the file format, path, or access permissions | Check the file name, storage location, and access permissions |
| The answer is too generic | Your own file or knowledge is not specified | Explicitly specify the target file or knowledge |
| The output differs from expectations | The question is ambiguous | Specify the target, conditions, and output format |
| Too many findings | The scope or perspectives are too broad | Narrow it to one chapter and 3-5 perspectives |
| Too few findings | The review perspectives are abstract, or the design document lacks information | Make the perspectives more concrete and check the input document |
| Asserting content not in the design document | Insufficient instruction to suppress guessing | Explicitly state "do not assert content that is not described" |
| The output format breaks down | The output format specification is ambiguous | Explicitly specify the table or JSON format and column names |
| Cannot output to Excel | A problem with the sheet name, column names, or write permissions | Use a verification file as the output destination and check the format |
| Not registered in the external tool | A problem with the startup state, permissions, or integration settings | Check the prerequisites on the sample page |
| Hard to explain the evaluation results | The evaluation perspectives have not been decided | Organize them using the evaluation notes template |
Points to Check
Evaluating Your Own Files
In your evaluation, check not only whether it worked, but also the following.
| Evaluation Perspective | What to Check |
|---|---|
| Input compatibility | Whether the AI can work with your own file |
| Output quality | Whether the output is at a level of detail usable in business |
| Evidence basis | Whether the output is based on your own file |
| Suppression of guesses | Whether content not described is being asserted |
| Ease of revision | Whether the format is easy for people to check and revise |
| Reproducibility | Whether it seems usable repeatedly for similar tasks |
| Ease of adjustment | Whether the perspectives, questions, and output format are easy to adjust |
| Business impact | Whether it seems likely to lead to time savings, quality improvement, and prevention of omissions |
The Difference from a Typical AI Chat
When evaluating with your own files, also check the difference from a typical AI chat.
| Comparison Perspective | Typical AI Chat | Agentiqs |
|---|---|---|
| File usage | Tends to depend only on the content pasted in on the spot | Can refer to files and knowledge |
| Reusing business AI | You need to write the prompt every time | The role can be saved as an AI agent |
| Routine processing | You request it manually every time | It can be run as a workflow |
| Output destination | Mainly chat answers | Can output to Excel, Markdown, Word, and external tools |
| Review perspectives | Tend to be entered manually every time | Can be used as a perspective file or knowledge |
| Team rollout | Tends to become individual use | AI agents and workflows are easy to share |
Next Steps After the Evaluation
Once you finish your 90-minute evaluation with your own files, choose the next step based on the results.
| Evaluation Result | Next Step |
|---|---|
| The output quality is good | Consider turning it into an AI agent or a workflow |
| The output is good but the format needs work | Adjust the output format or the Excel output |
| The findings or answers are generic | Improve the question, review perspectives, and knowledge |
| The input file is hard to work with | Organize the document structure, headings, terminology, and scope |
| There seems to be a business impact | Try it on a small scale within your team |
| You cannot judge yet | Re-evaluate with a different business theme or a different file |
If You Turn It into an AI Agent
If it seems usable repeatedly for the same business task, consider turning it into an AI agent.
Conditions Suited to Becoming an AI Agent
| Condition | Description |
|---|---|
| Clear business purpose | You can explain what the AI is meant to support |
| Fixed input data | The design document, FAQ, meeting notes, etc. are clear |
| Fixed output format | A table, meeting minutes format, list of findings, etc. |
| A judgment standard exists | Review perspectives, quality standards, severity criteria, etc. |
| Used repeatedly | Expected to be used continuously for the same business task |
Related pages:
If You Turn It into a Workflow
If you perform multiple processes every time, consider turning it into a workflow.
Conditions Suited to Becoming a Workflow
| Condition | Description |
|---|---|
| Fixed procedure | The flow of input, processing, and output is clear |
| Multiple steps | Combines reading, analysis, formatting, output, etc. |
| Run repeatedly | The same processing is run many times |
| Fixed output destination | Excel, Markdown, Lightning Review, etc. |
| Want to use it as a team | Want to make it a business process rather than individual work |
Related pages:
If You Move on to Organizing Knowledge
If there seems to be a benefit for document search or inquiry response, move on to organizing your knowledge.
What to Organize
| Item to Organize | Description |
|---|---|
| Document selection | Narrow down the documents used to the latest versions |
| Knowledge splitting | Split by product, business task, or use case |
| Terminology organization | Prepare a glossary or list of abbreviations |
| Question templates | Prepare frequently used questions |
| Answer rules | Decide policies such as not asserting content that is not described |
Related pages:
Notes
- When trying it with your own files, always use a copy made for verification.
- When handling confidential information, personal information, or customer information, follow your internal rules and security policies.
- Treat the AI's output as a draft for the person in charge to review, not as the final deliverable.
- When outputting or registering to an external tool, check the registration destination and the target to be updated in advance.
- Before outputting directly to a production file, production project, or production review, always confirm it with verification data first.
- When evaluating, use files for which you know the correct answer or expected result as much as possible.
What to Check After Completing the 90-Minute Course
After trying it with your own business files, check the following.
| Check Item | Description |
|---|---|
| Whether it ran with your own files | Whether you were able to replace the input file and run it |
| Whether the output is valid | Whether the person in charge thinks the content seems usable |
| Whether the evidence is clear | Whether it is based on the content of your own file |
| Whether you found adjustment points | Whether you identified improvements to the question, perspectives, output format, etc. |
| Whether you decided on candidate use cases | Whether you decided which business task to continue verifying |
| Whether you decided the next action | Creating an AI agent, building a workflow, organizing knowledge, etc. |
Pages to Go to Next
Depending on your purpose, go to the following page.
| Purpose | Next Page |
|---|---|
| Return to the overview of the usage guide | About the Usage Guide |
| Check how to get started with the evaluation version | Evaluation Version Start Guide |
| Experience the value of Agentiqs in 90 minutes | Experience the Value of Agentiqs |
| Check the sample data | Sample Data List |
| Utilize knowledge | Utilizing Knowledge |
| Create an AI agent | Creating an AI Agent Specialized for Reviews |
| Create a workflow | Creating a Workflow for Comprehensive Review |
| Check the tool list | Tool List |