CORU-10M-ACT
Lightweight Automation Action-Routing Model
Natural Language → Intent Understanding → Action Routing → Structured Proposals
An efficient, schema-guided automation model engineered to transform natural-language requests into structured, application-ready action proposals.
Source Runtime • Brand Updates • Professional Contact
1. Model Overview
CORU-10M-ACT belongs to the CORU Automation model family. It is a compact, purpose-built Automation Action-Routing Model, not a general-purpose conversational language model.
CORU is designed to interpret a user's intent, identify the appropriate action declared by an application's automation schema, organize the required parameters, and return a structured proposal that a trusted host application can validate and, when authorized, execute.
Its design focuses on:
- Lightweight model footprint for practical deployment.
- Schema-guided tool and action selection.
- Structured parameter proposal rather than unconstrained prose.
- Clarification and confirmation-aware response fields.
- A shared inference path for CPU and TPU/XLA environments.
- Integration into applications through a controlled host-runtime layer.
2. Model Specifications
| Specification | Details |
|---|---|
| Model family | CORU Automation |
| Model type | Automation Action-Routing Model |
| Parameter count | 9,995,264 (~9.995M) |
| Tokenizer vocabulary | 7,680 |
| Maximum context length | 512 tokens |
| Declared action schema | 55 actions |
| Action namespaces | 23 |
| Pretraining scale | 1 billion tokens |
| Development programme | 20 sequential stages |
| Accelerator platform | Google Cloud TPU v5e |
| Aggregate accelerator time | 25+ hours |
| Inference formats | Structured action proposals |
| Weight format | Safetensors |
3. Automation Capabilities
CORU is intended to serve as the intent-to-action routing component inside a larger automation application. Its schema-led design can support host-integrated workflows such as:
- Communication workflows: routing requests to configured messaging or email actions.
- Notes and documents: preparing structured note, document, and content operations.
- Tasks and scheduling: identifying configured task, reminder, and calendar actions.
- File workflows: routing file-related requests to approved storage or document adapters.
- Web-connected workflows: selecting declared search, retrieval, or service actions exposed by the host application.
- Productivity automation: mapping user intent to the tools and operations registered by an application.
The available operations are determined by the action schema and the connectors enabled by the host application. These examples describe integration domains; they do not imply that external services are bundled with the model.
Core routing functions
- Intent interpretation — identify the operational intent expressed in natural language.
- Tool selection — select a tool or namespace represented in the declared action schema.
- Action selection — map the request to a specific schema action.
- Parameter structuring — prepare a structured parameter object for host-side validation.
- Clarification handling — signal when required information is missing or ambiguous.
- Confirmation signaling — expose whether the host should request explicit user confirmation.
4. Structured Proposal Interface
CORU returns structured action proposals using a contract with the following fields:
{
"tool": "<tool_or_namespace>",
"action": "<declared_action>",
"parameters": {},
"status": "proposed",
"needs_confirmation": false,
"clarification": null
}
| Field | Purpose |
|---|---|
tool |
Identifies the selected tool or action namespace. |
action |
Identifies the selected operation within that tool. |
parameters |
Carries the proposed arguments as structured data. |
status |
Communicates the proposal state, including clarification states where applicable. |
needs_confirmation |
Signals whether the host should obtain explicit approval. |
clarification |
Provides a question or missing-information prompt when needed. |
The host application should validate every proposal against the published action schema before using it. A well-formed response is not, by itself, proof that the selected action is semantically correct or authorized.
5. Training and Development Profile
CORU-10M-ACT was developed through a 20-stage training and refinement programme, with a completed 1-billion-token pretraining scale.
The high-level programme was organized as follows:
- Four pretraining stages established the model's foundational automation and action-routing representations.
- Sixteen subsequent refinement stages were conducted as separate training stages on Google Cloud TPU v5e accelerator hardware.
- The overall development programme accumulated more than 25 hours of TPU accelerator time across training and refinement.
This summary communicates the model's development scale and compute platform without publishing proprietary implementation details. Internal datasets, exact training recipes, optimizer configurations, checkpoint histories, private experiment records, and other non-public development materials are intentionally not included in this Model Card.
6. Recorded Evaluation Profile
The following percentages summarize the recorded evaluation profile. The two columns distinguish the hybrid processing path from direct model output.
| Evaluation dimension | Hybrid path | Direct model path |
|---|---|---|
| Structured route selection | 96.4% | 98.8% |
| Unseen instruction phrasing | 87.6% | 88.9% |
| Notes workflow extraction | 98.1% | 99.5% |
| Held-out note-context generalization | 99.3% | 99.3% |
| Safety-policy consistency | 100% | 100% |
These figures describe the recorded evaluation configuration and should be interpreted within the corresponding task definitions. Performance on a new application depends on its action schema, wording distribution, host-side validation, and connector implementation.
7. Inference and Deployment
CORU is designed to use the same model package and native inference runtime across supported execution environments.
| Environment | Runtime path |
|---|---|
| Standard CPU | PyTorch CPU |
| Google Cloud TPU v5e | PyTorch/XLA |
| Other compatible TPU/XLA devices | PyTorch/XLA, subject to runtime and device compatibility |
| NVIDIA GPU | CUDA where supported by the installed PyTorch build |
| Apple Silicon | MPS where supported by the installed PyTorch build |
With --device auto, the companion runtime prefers an active TPU/XLA backend, then checks CUDA, Apple MPS, and CPU. Explicitly requesting TPU/XLA requires a working TPU/XLA environment; the runtime does not silently report a CPU run as TPU execution.
Load the released model runtime
The companion runtime is maintained in the CORU-10M-ACT GitHub repository. It resolves the requested Hugging Face revision, downloads an immutable model snapshot, imports the model repository's native coru_inference.py, applies strict package-integrity checks, and calls the native model load() interface.
git clone https://github.com/rrrpro-ai/CORU-10M-ACT.git
cd CORU-10M-ACT
python coru_runtime.py --device auto
Force CPU inference
python coru_runtime.py --device cpu
Require TPU/XLA inference
python coru_runtime.py --device tpu
A TPU run requires a compatible PyTorch/XLA installation and an active TPU runtime. The runtime installs its Hugging Face Hub, Safetensors, and Tokenizers dependencies when missing; PyTorch and the matching accelerator runtime must be provisioned for the selected hardware environment.
8. Integrating CORU into an Application
CORU is best integrated as the decision and routing layer behind an application's backend—not as an unrestricted executor exposed directly to a browser or client.
Recommended application architecture
User Interface
│
â–¼
Application Backend / Orchestrator
│
â–¼
CORU Inference Runtime
│
â–¼
Structured Proposal
(tool · action · parameters · status · confirmation)
│
â–¼
Action-Schema Validation
│
â–¼
Authorization + Policy Checks
│
â–¼
User Confirmation (when required)
│
â–¼
Connector / Adapter Registry
│
â–¼
External Application or Service
│
â–¼
Result Handling + Audit Record
Integration responsibilities
- Inference layer: load CORU through its native runtime and obtain a structured proposal for each request.
- Schema layer: verify that
toolandactionare declared and thatparameterssatisfy the action's required types and fields. - Policy layer: enforce the signed-in user's identity, role, permissions, application policy, and data boundaries.
- Confirmation layer: request explicit approval for sensitive, irreversible, or externally visible operations.
- Adapter layer: map approved tool/action pairs to application-specific API clients or service connectors.
- Execution layer: execute only the validated and authorized operation; handle timeouts, retries, idempotency, and service errors.
- Audit layer: record the request, selected route, approval decision, execution result, and relevant trace identifiers without exposing secrets.
Example host-side control flow
def handle_automation_request(user_text, user_context):
proposal = coru_inference_for_host(user_text)
action_schema.validate(proposal)
authorization.require_allowed(user_context, proposal)
if proposal["needs_confirmation"]:
return confirmation_service.request(user_context, proposal)
adapter = connector_registry.resolve(
proposal["tool"],
proposal["action"],
)
return adapter.execute(proposal["parameters"], user_context)
coru_inference_for_host, action_schema, authorization, confirmation_service, and connector_registry are host-application integration components. They must be implemented by the application; they are not claimed as built-in model functions.
Execution boundary: CORU produces proposals. It does not independently send emails, modify files, access accounts, control applications, or execute external services. Those operations remain under the host application's connectors, permissions, confirmation rules, and audit controls.
9. Runtime and Integration Resources
- Model repository: rrrpromex/CORU-10M-ACT
- Source runtime and application integration: rrrpro-ai/CORU-10M-ACT
- Brand and developer profile: RRR PRO MEX on GitHub
10. Brand and Contact
RRR PRO MEX is the independent technology brand behind CORU-10M-ACT, focused on software, automation systems, and practical AI-powered tools.
- Brand updates: RRR PRO MEX on Bluesky
- Professional contact: RRR PRO MEX on LinkedIn
- Source code and engineering resources: RRR PRO MEX on GitHub
- Model distribution: CORU-10M-ACT on Hugging Face
© All Rights Reserved By RRR PRO MEX
- Downloads last month
- -